Files
CADmind/backend/tests/quality/test_thread_reliability.py
2026-09-24 10:40:57 +08:00

220 lines
13 KiB
Python

"""Real threaded solids, interrupted walls, and saved failure recovery."""
import json
import math
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from build123d import Box
from engine.agent_session import AgentSession
from engine.registry import load_registry
from engine.cad_export import export_verified
from engine.worker_resources import memory_exceeded
ROOT = Path(__file__).resolve().parents[2]
class ThreadReliabilityTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.registry = load_registry(ROOT/'capabilities')
def test_measurement_does_not_alias_a_twenty_turn_helix(self):
from build123d import Helix
from engine.inspection import z_helical_measurements
result=z_helical_measurements(Helix(2,40,10))
self.assertEqual(result['signed_lead_mm_range'],[2,2])
self.assertEqual(result['hand'],'right')
self.assertEqual(result['measured_flank_faces'],0)
def test_round_wire_rejects_touching_and_overlapping_turns(self):
for radius in (1, 1.25, 2.5):
s = AgentSession(self.registry)
result = s.apply_op('helical_sweep', dict(pitch=2, height=15, coil_radius=29,
profile_radius=radius, lefthand=False))
self.assertFalse(result['ok'])
self.assertIn('SELF_INTERSECTION', result['error'])
self.assertEqual(s.trace, [])
def test_metric_threads_remain_real_and_valid_after_four_radial_windows(self):
for diameter, pitch, length, bore, hand in [(12, 1.5, 6, 6, "right"), (60, 2, 15, 52, "right"), (20, 1.5, 6, 12, "left")]:
with self.subTest(diameter=diameter):
s = AgentSession(self.registry)
result = s.apply_op('metric_thread', dict(major_diameter=diameter, pitch=pitch,
length=length, inner_diameter=bore, hand=hand, end_finish='square'), op_id='thread')
self.assertTrue(result['ok'], result)
original = s.context['thread']
self.assertEqual(len(original.solids()), 1)
root=diameter/2-.5412658773652742*pitch
self.assertGreater(original.volume,math.pi*(root*root-bore*bore/4)*length)
self.assertTrue(original.is_inside(((root+bore/2)/2,0,length/2)))
self.assertFalse(original.is_inside((0,0,length/2)))
self.assertAlmostEqual(original.bounding_box().size.Z, length, places=4)
# A point near the crest alternates solid/air across one pitch.
samples=[original.is_inside((diameter/2-pitch*.12,0,length/2+i*pitch/16)) for i in range(17)]
self.assertTrue(any(samples))
self.assertFalse(all(samples))
target='thread'
for i in range(4):
a=i*math.pi/2
r=s.apply_op('cut_openings', dict(origin=[0,0,length/2],
normal=[math.cos(a),math.sin(a),0], x_axis=[-math.sin(a),math.cos(a),0],
through_all=False,start_depth=bore/2-.3,depth=(diameter-bore)/2+1,
openings=[dict(kind='rectangle',length=pitch*2,width=pitch*1.5)]), target=target,op_id=f'window{i}')
self.assertTrue(r['ok'],r)
target=r['id']
final=s.context[target]
self.assertTrue(final.is_valid)
self.assertEqual(len(final.solids()),1)
self.assertLess(final.volume,original.volume)
from engine.inspection import inspect_geometry
measured=inspect_geometry(final)
helix=measured['helical_measurements']
self.assertEqual(helix['hand'],hand)
for lead in helix['signed_lead_mm_range']:
self.assertAlmostEqual(lead,pitch if hand=='right' else -pitch,places=3)
for angle in helix['symmetric_axial_profile_angle_deg_range']:
self.assertAlmostEqual(angle,60,delta=.05)
self.assertTrue(measured['planar_faces'])
for i in range(4):
a=i*math.pi/2
self.assertFalse(final.is_inside(((bore/2+.15)*math.cos(a),(bore/2+.15)*math.sin(a),length/2)))
with tempfile.TemporaryDirectory() as tmp:
check=export_verified(final,Path(tmp)/'model.step',Path(tmp)/'model.stl')
self.assertTrue(check['step_roundtrip_valid'])
def test_union_keeps_core_when_other_contains_multiple_solids(self):
from build123d import Compound, Pos
s=AgentSession(self.registry)
s.context['core']=Box(10,10,10)
s.context['details']=Compound(children=[Pos(5,0,0)*Box(4,4,4),Pos(-5,0,0)*Box(4,4,4)])
r=s.apply_op('boolean_combine',dict(with_id='details',operation='union'),target='core')
self.assertTrue(r['ok'],r)
result=s.context[r['id']]
self.assertAlmostEqual(result.volume,1064,places=5)
self.assertTrue(result.is_inside((0,0,0)))
self.assertEqual(len(result.solids()),1)
def test_missing_candidate_measurements_are_not_external_source_blockers(self):
from types import SimpleNamespace as S
from engine.quality_models import review_information_blockers, ReviewFinding
item=S(status='unverified',requirement_id='thread')
brief=S(due=lambda stage:[S(id='thread',critical=True,envelope_dimension=None)])
finding=ReviewFinding(category='measurement',requirement_id='thread',message='measure pitch',evidence='not measured')
review=S(items=[item],findings=[finding])
self.assertEqual(review_information_blockers(brief,'base',review),[])
finding.category='information'
self.assertEqual(review_information_blockers(brief,'base',review),[item])
def test_memory_guard_checks_descendants_without_counting_address_reservations(self):
with patch('engine.worker_resources.psutil.Process') as process, patch('engine.worker_resources.process_footprint', return_value=600):
root=process.return_value
root.children.return_value=[root]
self.assertIn('CADMemoryLimit',memory_exceeded(123,1000))
self.assertIsNone(memory_exceeded(123,2000))
def test_partial_batch_exports_checkpoint_without_claiming_review_pass(self):
from engine.quality_pipeline import QualityWorkflow
from engine.quality_models import Brief
from types import SimpleNamespace
from engine.job import write_json
import time
with tempfile.TemporaryDirectory() as tmp:
job=SimpleNamespace(path=Path(tmp),started=time.monotonic(),
config=SimpleNamespace(max_elapsed_seconds=600),write=lambda name,data:write_json(Path(tmp)/name,data),
event=lambda *a,**k:None,state=lambda *a,**k:None)
brief=Brief(name='test',coordinate_system='Z up',body_interpretation='one',requirements=[dict(id='body',description='one solid',stage='base',source='explicit',evidence='request',critical=True,envelope_dimension=None)],assumptions=[],unresolved=[],stage_plan=[])
w=QualityWorkflow(None,job,self.registry,brief,'',[])
w.session.context['seed']=Box(20,20,10)
result=w.batch({'mode':'append','operations':[
{'op':'cut_openings','id':'hole','target':'seed','params':dict(origin=[0,0,0],normal=[0,0,1],x_axis=[1,0,0],openings=[dict(kind='circle',diameter=2)])},
{'op':'missing','id':'bad','params':{}}]})
self.assertFalse(result['ok'])
saved=list(Path(tmp).glob('checkpoint_[0-9]*'))
self.assertEqual(len(saved),1)
self.assertTrue((saved[0]/'model.step').exists())
self.assertEqual(json.loads((saved[0]/'model.json').read_text())['output'],'hole')
self.assertIsNone(w.last_candidate)
class ClaimContractTests(unittest.TestCase):
def test_submission_contract_rejects_invented_types_and_wrong_axis_fields(self):
from engine.claims import claim_schema, check_claims
variants={v["properties"]["type"]["enum"][0]:v for v in claim_schema()["items"]["anyOf"]}
for claim in [dict(type='helix',target='body',pitch=2),
dict(type='axis_direction',target='body',axis='Z',expected='Z')]:
self.assertTrue(check_claims([claim],{},[]))
variant=variants.get(claim["type"])
self.assertTrue(variant is None or set(variant["required"]) - set(claim))
self.assertFalse(check_claims([dict(type="dimension",target="body",axis="Z",expected_mm=35)],{"body":Box(10,10,35)},[]))
self.assertFalse(check_claims([],{},[]))
registry=load_registry(ROOT/'capabilities')
from engine.quality_tools import quality_tools
tools={t['name']:t for t in quality_tools(registry)}
for tool in ('submit_stage','execute_batch'):
self.assertEqual(tools[tool]['parameters']['properties']['claims'],claim_schema())
class LocalChamferTests(unittest.TestCase):
def test_local_chamfer_uses_explicit_target_not_stale_edge_parent(self):
s=AgentSession(load_registry(ROOT/'capabilities'))
shape=Box(10,10,10);s.context['body']=shape
edges=shape.edges()
edges[0].topo_parent=Box(2,2,2)
with patch.object(shape,'edges',return_value=edges):
result=s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=[0]),target='body')
self.assertTrue(result['ok'],result)
self.assertAlmostEqual(s.context[result['id']].bounding_box().size.X,10)
def test_thread_lead_in_is_on_external_crest_not_inner_bore(self):
from engine.inspection import conical_boundaries
s=AgentSession(load_registry(ROOT/'capabilities'))
result=s.apply_op('metric_thread',dict(major_diameter=60,pitch=2,length=15,inner_diameter=52,end_chamfer=.5),op_id='thread')
self.assertTrue(result['ok'],result)
cones=conical_boundaries(s.context['thread'])
self.assertEqual(len(cones),2)
for cone in cones:
self.assertAlmostEqual(cone['radius_range_mm'][0],29.5,places=4)
self.assertAlmostEqual(cone['radius_range_mm'][1],30,places=4)
self.assertAlmostEqual(cone['axial_extent_mm'],.5,places=4)
self.assertAlmostEqual(cone['half_angle_deg'],45,places=4)
self.assertTrue(s.context['thread'].is_inside((26.1,0,.1)))
self.assertFalse(s.context['thread'].is_inside((25.9,0,.1)))
# Tiny planar thread-end slivers must be meshed, not silently skipped.
from engine.render import render_shape_png
import struct
from collections import Counter
with tempfile.TemporaryDirectory() as tmp:
export_verified(s.context['thread'],Path(tmp)/'model.step',Path(tmp)/'model.stl')
self.assertTrue(render_shape_png(s.context['thread'],size=160).startswith(b'\x89PNG'))
data=(Path(tmp)/'model.stl').read_bytes()
edges=Counter()
for i in range(struct.unpack_from('<I',data,80)[0]):
values=struct.unpack_from('<12fH',data,84+50*i)[3:12]
pts=[tuple(round(v,5) for v in values[j:j+3]) for j in (0,3,6)]
if len(set(pts))<3: continue
for a,b in ((0,1),(1,2),(2,0)): edges[tuple(sorted((pts[a],pts[b])))]+=1
self.assertTrue(edges)
self.assertTrue(all(count==2 for count in edges.values()),'STL contains open or non-manifold mesh edges')
def test_local_hole_rim_chamfer_and_independent_cone_measurement(self):
from build123d import Cylinder, GeomType
from engine.inspection import inspect_geometry
s=AgentSession(load_registry(ROOT/'capabilities'))
shape=Cylinder(5,10)-Cylinder(2,10)
s.context['ring']=shape
index=next(i for i,e in enumerate(shape.edges()) if e.geom_type==GeomType.CIRCLE and abs(e.radius-2)<1e-6 and abs(e.center().Z-5)<1e-6)
evidence=inspect_geometry(shape,include_edges=True)
self.assertEqual(evidence['edges']['items'][index]['index'],index)
for indices in ([9999],[index,index]):
self.assertFalse(s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=indices),target='ring')['ok'])
result=s.apply_op('chamfer_edge',dict(radius=.3,edge_selector='by_index',edge_indices=[index]),target='ring',op_id='finished')
self.assertTrue(result['ok'],result)
final=s.context['finished']
self.assertLess(final.volume,shape.volume)
measured=inspect_geometry(final)
self.assertEqual(len(measured['conical_faces']),1)
cone=measured['conical_faces'][0]
self.assertAlmostEqual(cone['half_angle_deg'],45,places=4)
self.assertAlmostEqual(cone['axial_extent_mm'],.3,places=4)
self.assertAlmostEqual(cone['radial_extent_mm'],.3,places=4)