Files
2026-09-24 10:40:57 +08:00

218 lines
12 KiB
Python

import base64
import copy
import io
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from build123d import Box, Circle, Cylinder, Plane, Pos, fillet
from PIL import Image
from engine.agent_session import AgentSession
from engine.claims import check_claims
from engine.config import QualityConfig
from engine.executor import run_ir, IRError
from engine.images import normalize_images, crop_reference
from engine.job import QualityJob, BudgetExceeded
from engine.postcondition import check_postcondition, PostconditionError
from engine.quality_models import Brief, Review, assess_review, dimension_errors
from engine.quality_pipeline import QualityWorkflow
from engine.registry import load_registry
from engine.validation import safe_name, solid_errors
ROOT = Path(__file__).resolve().parents[2]
REGISTRY = load_registry(ROOT / 'capabilities')
OPS = [dict(op='sketch_rect', id='s', target=None, params=dict(width=10,height=20,x_offset=-5,y_offset=-10)),
dict(op='extrude', id='body', target='s', params=dict(amount=30))]
def brief():
return Brief.model_validate(dict(name='plate',coordinate_system='XYZ',body_interpretation='rectangular body',
requirements=[dict(id='body',description='10 mm wide body',stage='base',source='explicit',
evidence='user says 10 mm',critical=True,
envelope_dimension=dict(axis='X',expected_mm=10,tolerance_mm=.1))],
assumptions=[],unresolved=[],stage_plan=['base','features','detail']))
def review(status='pass'):
return Review.model_validate(dict(items=[dict(requirement_id='body',status=status,evidence='Measured X=10',repair='')],additional_issues=[]))
class GeometryTests(unittest.TestCase):
def test_invalid_params_and_duplicate_ids_preserve_state(self):
session=AgentSession(REGISTRY)
for params in ({}, {'radius':float('nan')}, {'radius':'inf'}, {'radius':2,'unknown':3}, []):
self.assertFalse(session.apply_op('sketch_circle',params)['ok'])
self.assertTrue(session.apply_op('sketch_circle',{'radius':2},op_id='s')['ok'])
self.assertFalse(session.apply_op('sketch_circle',{'radius':3},op_id='s')['ok'])
self.assertEqual(len(session.trace),1)
def test_empty_target_legacy_reports_still_replay(self):
ops=copy.deepcopy(OPS);ops[0]['target']=''
with tempfile.TemporaryDirectory() as d:
r=run_ir({'name':'legacy','operations':ops,'output':'body'},REGISTRY,d)
self.assertAlmostEqual(r['volume_mm3'],6000)
def test_final_sketch_rejected(self):
self.assertTrue(solid_errors(Circle(3)))
with tempfile.TemporaryDirectory() as d:
with self.assertRaises(IRError):
run_ir({'name':'bad','operations':OPS[:1],'output':'s'},REGISTRY,d)
def test_hole_rejects_empty_space_wrong_diameter_and_blocked(self):
shape=Box(20,20,10)-Cylinder(2,12)
claim=dict(type='hole',target='part',axis='Z',diameter=4,x=0,y=0,z=0)
self.assertEqual(check_claims([claim],{'part':shape},[]),[])
for changed in ({'x':30},{'diameter':3}):
self.assertTrue(check_claims([{**claim,**changed}],{'part':shape},[]))
self.assertTrue(check_claims([claim],{'part':shape+Box(2,2,1)},[]))
def test_small_cut_and_face_contact(self):
session=AgentSession(REGISTRY)
session.context.update(a=Box(10,10,10),b=Pos(4.99,0,0)*Box(.02,1,1))
r=session.apply_op('boolean_combine',{'with_id':'b','operation':'cut'},target='a')
self.assertTrue(r['ok'],r)
self.assertLess(session.context[r['id']].volume,1000)
session.context['b']=Pos(10,0,0)*Box(10,10,10)
r=session.apply_op('boolean_combine',{'with_id':'b','operation':'union'},target='a')
self.assertTrue(r['ok'],r)
self.assertEqual(r['solids'],1)
def test_sketch_boolean_cut_uses_area(self):
with tempfile.TemporaryDirectory() as d:
r=run_ir(json.loads((ROOT/'examples/demo_sketch_offset.json').read_text()),REGISTRY,d)
self.assertGreater(r['volume_mm3'],1000)
def test_snapshot_depth_hides_back_surfaces_and_preserves_hole(self):
from engine.render import render_shape_png
shape=Box(20,20,10)-Cylinder(5,15)
png=render_shape_png(shape,'top',size=160)
img=Image.open(io.BytesIO(png))
self.assertEqual(img.getpixel((80,85)),(245,246,248))
self.assertNotEqual(img.getpixel((30,85)),(245,246,248))
def test_offline_comparison_handles_axis_rotation_without_scaling(self):
from build123d import export_step, Rot
from scripts.compare_geometry import compare_step_files, orthogonal_rotations
self.assertEqual(len(list(orthogonal_rotations())),24)
shape=Box(20,13,7)-Pos(8,5,0)*Box(6,5,20)
with tempfile.TemporaryDirectory() as d:
reference=Path(d)/'reference.step'; candidate=Path(d)/'candidate.step'
export_step(shape,str(reference))
export_step(Pos(30,-10,5)*Rot(90,0,0)*shape,str(candidate))
result=compare_step_files(reference,candidate)
self.assertGreater(result['best_axis_aligned_volume_iou'],.99999)
self.assertLess(result['volume_relative_error'],1e-5)
def test_local_plane_axis(self):
s=AgentSession(REGISTRY)
s.apply_op('sketch_circle',{'radius':2},op_id='s')
r=s.apply_op('place_on_plane',{'origin':[0,-10,0],'x_axis':[1,0,0],'normal':[0,1,0]},target='s',op_id='p')
self.assertTrue(r['ok'],r)
r=s.apply_op('extrude',{'amount':20},target='p')
self.assertTrue(r['ok'],r)
self.assertAlmostEqual(s.context[r['id']].bounding_box().size.Y,20)
self.assertFalse(s.apply_op('place_on_plane',{'origin':[0,0,0],'x_axis':[1,0,0],'normal':[1,0,0]},target='s')['ok'])
def test_concave_fillet_can_add_material(self):
shape=Box(20,20,10)-Pos(5,5,0)*Box(10,10,20)
edge=min(shape.edges(),key=lambda e: (e.center()-__import__('build123d').Vector(0,0,0)).length)
result=fillet(edge,1)
self.assertGreater(result.volume,shape.volume)
check_postcondition('fillet_edge','geometry_changed',shape,result)
with self.assertRaises(PostconditionError):
check_postcondition('fillet_edge','geometry_changed',shape,shape)
class WorkflowTests(unittest.TestCase):
def test_reference_crop_preserves_pixels_and_is_sent_to_review(self):
source=Image.new('RGB',(20,16),'blue');source.paste('red',(4,4,12,12))
buffer=io.BytesIO();source.save(buffer,format='PNG')
images=normalize_images(base64.b64encode(buffer.getvalue()).decode())
metadata,png=crop_reference(images,1,[4,4,12,12])
self.assertEqual(Image.open(io.BytesIO(png)).size,(8,8))
self.assertEqual(Image.open(io.BytesIO(png)).getpixel((0,0)),(255,0,0))
self.assertEqual(metadata['source_sha256'],images[0]['sha256'])
with self.assertRaises(ValueError):crop_reference(images,1,[-1,0,8,8])
with tempfile.TemporaryDirectory() as d:
job=QualityJob(d,'test',images,QualityConfig())
w=QualityWorkflow(None,job,REGISTRY,brief(),'test',images)
w.dispatch('rebuild_model',{'operations':copy.deepcopy(OPS)})
w.crop({'image_index':1,'box':[4,4,12,12]})
with patch('engine.quality_pipeline.structured_call',return_value=review()) as call, patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
self.assertTrue(w.submit({'output_id':'body'})['ok'])
texts=[x.get('text','') for x in call.call_args.args[3]]
self.assertTrue(any(images[0]['sha256'] in t for t in texts))
self.assertEqual((job.path/'input_1.png').read_bytes(),buffer.getvalue())
def test_review_cannot_omit_or_duplicate_or_waive_critical(self):
self.assertFalse(assess_review(brief(),'base',review()))
self.assertTrue(assess_review(brief(),'base',review('unverified')))
r=review(); r.items=[]
self.assertTrue(assess_review(brief(),'base',r))
r=review(); r.items*=2
self.assertTrue(assess_review(brief(),'base',r))
self.assertTrue(dimension_errors(brief(),'detail',Box(12,20,30)))
def test_rebuild_is_atomic_and_stages_require_review(self):
with tempfile.TemporaryDirectory() as d:
job=QualityJob(d,'test',[],QualityConfig())
w=QualityWorkflow(None,job,REGISTRY,brief(),'test',[])
self.assertTrue(w.dispatch('rebuild_model',{'operations':copy.deepcopy(OPS)})['ok'])
before=w.session
bad=copy.deepcopy(OPS); bad[1]['params']['amount']=-1
self.assertFalse(w.dispatch('rebuild_model',{'operations':bad})['ok'])
self.assertIs(w.session,before)
with patch('engine.quality_pipeline.structured_call',return_value=review('fail')), patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
self.assertFalse(w.submit({'output_id':'body'})['ok'])
self.assertEqual(w.stage_index,0)
original_len=len(w.last_candidate[1]['operations'])
w.session.apply_op('sketch_circle',{'radius':2},op_id='extra')
self.assertEqual(len(w.last_candidate[1]['operations']),original_len)
partial=w.publish(True)
self.assertEqual(partial['quality_status'],'partial')
self.assertEqual(len(json.loads(Path(partial['published_model_file']).read_text())['operations']), original_len)
with patch('engine.quality_pipeline.structured_call',return_value=review()), patch('engine.quality_pipeline.render_shape_png',return_value=b'png'):
for i in range(3):
self.assertTrue(w.submit({'output_id':'body'})['ok'])
self.assertEqual(w.stage_index,i+1)
self.assertEqual(w.publish(True)['quality_status'],'passed')
def test_job_budget_and_original_image_are_durable(self):
b=io.BytesIO();Image.new('RGB',(8,8)).save(b,format='PNG')
images=normalize_images(base64.b64encode(b.getvalue()).decode())
with tempfile.TemporaryDirectory() as d:
j=QualityJob(d,'original',images,QualityConfig(max_calls=1))
self.assertEqual((j.path/'input_1.png').read_bytes(),b.getvalue())
self.assertEqual(json.loads((j.path/'request.json').read_text())['text'],'original')
j.calls=1
with self.assertRaises(BudgetExceeded):j.call(None,'build')
for value in ['../model','a/b','', 'a.b']:
with self.assertRaises(ValueError):safe_name(value)
with self.assertRaises(ValueError):normalize_images(['invalid'])
with self.assertRaises(ValueError):normalize_images(['eA==']*6)
def test_resume_endpoint_validates_and_returns_new_candidate(self):
from web.app import app
client=app.test_client()
self.assertEqual(client.post('/api/resume',json={'part_name':'../x'}).status_code,400)
with patch('web.app.run_isolated',return_value={'part_name':'new_version','quality_mode':True,'quality_status':'partial'}) as call:
response=client.post('/api/resume',json={'part_name':'old_version'})
self.assertEqual(response.status_code,200)
self.assertEqual(response.json['part_name'],'new_version')
self.assertTrue(response.json['can_resume'])
self.assertEqual(call.call_args.args[0],'resume')
self.assertEqual(call.call_args.kwargs['part_name'],'old_version')
def test_api_does_not_label_legacy_or_partial_as_passed(self):
from web.app import _report_to_response, app
self.assertEqual(_report_to_response({'part_name':'old'})['quality_status'],'unverified')
self.assertEqual(_report_to_response({'part_name':'partial','quality_status':'partial'})['quality_status'],'partial')
client=app.test_client()
for payload in ([1],{'text':5},{'text':'part','images':'abc'}, {'text':'part','images':['a']*6}):
self.assertEqual(client.post('/api/generate',json=payload).status_code,400)
if __name__=='__main__': unittest.main()