SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
"""Regression tests for reference data, physical scope and loss-aware projection."""
import copy
import json
import math
from pathlib import Path
import tempfile
import unittest
import physical as p
class PhysicalTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.data,cls.sources,cls.bindings,cls.registry=[p.read(p.PACK/name) for name in ('profiles.json','sources.json','bindings.json','quantities.json')]
cls.profiles,cls.source_map=p.validate_data(cls.data,cls.sources,cls.bindings,cls.registry)
def mutated(self,which,change):
args=copy.deepcopy([self.data,self.sources,self.bindings,self.registry]);change(args[which])
with self.assertRaises((p.Invalid,KeyError,TypeError)):p.validate_data(*args)
def row(self,id,quantity):
return next(x for x in self.profiles[id]['properties'] if x['quantity']==quantity)
def test_all_profiles_and_associations_validate(self):
self.assertGreaterEqual(len(self.profiles),51)
self.assertEqual(len(self.bindings['catalog']),600)
self.assertEqual(len(self.bindings['surfaces']),48)
def test_duplicate_json_fields_and_nonfinite_literals_refuse(self):
with self.assertRaises(p.Invalid):json.loads('{"density":1,"density":2}',object_pairs_hook=p.unique)
for value in ('NaN','Infinity','-Infinity'):
with self.assertRaises(p.Invalid):json.loads('{"value":'+value+'}',parse_constant=p.reject_constant)
def test_numeric_boolean_text_infinity_and_huge_integers_refuse(self):
for v in (True,False,'1',float('nan'),float('inf'),10**400,-10**400):
with self.subTest(v=repr(v)[:20]),self.assertRaises(p.Invalid):p.number(v)
def test_units_and_source_arithmetic_are_checked(self):
row=copy.deepcopy(self.row('aluminium-6061-t6','young_modulus'))
for change in (lambda x:x.update(unit='MPa'),lambda x:x.update(value=x['value']/1000),
lambda x:x['original'].update(scale_to_si=1),lambda x:x['original'].update(unit='degC')):
bad=copy.deepcopy(row);change(bad)
with self.assertRaises(p.Invalid):p.check_property(bad,self.source_map)
def test_temperature_conversions_are_affine_not_scalar(self):
r=self.row('epoxy-690','heat_deflection')
self.assertAlmostEqual(r['value'],(115-32)*5/9+273.15,places=9)
self.assertIsNone(r['conditions']['temperature_k'])
self.assertAlmostEqual(self.row('pom-c','glass_transition')['value'],213.15)
def test_electrical_resistivity_and_breakdown_have_distinct_units(self):
self.assertAlmostEqual(self.row('steel-304-plate','volume_resistivity')['value'],74e-8)
self.assertAlmostEqual(self.row('ptfe','dielectric_strength')['value'],80e6)
self.assertAlmostEqual(self.row('silicone-ds20','dielectric_strength')['value'],350/.0000254,delta=1e-4)
def test_ranges_never_become_a_midpoint(self):
result=p.native_card(self.profiles['tpu95-feedstock'],self.source_map)
self.assertFalse(any(r['data']['kind']=='density' for r in result['card']['properties']))
with self.assertRaises(p.Invalid):p.prepare('tpu95-feedstock',True)
def test_reversed_range_and_wrong_range_qualifier_refuse(self):
r=copy.deepcopy(self.row('tpu95-feedstock','density'));r['value'].reverse()
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
r=copy.deepcopy(self.row('tpu95-feedstock','density'));r['qualifier']='typical'
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
def test_limits_are_not_native_nominal_strengths(self):
result=p.native_card(self.profiles['titanium-grade5'],self.source_map)
kinds={r['data']['kind'] for r in result['card']['properties']}
self.assertNotIn('yield_strength',kinds);self.assertNotIn('tensile_strength',kinds)
def test_missing_poisson_ratio_does_not_invent_elasticity(self):
for id in ('steel-304-plate','peek','pa6-stock','epoxy-690'):
result=p.native_card(self.profiles[id],self.source_map)
self.assertNotIn('elasticity',{r['data']['kind'] for r in result['card']['properties']})
def test_native_steel_c45_analytic_elastic_constants(self):
result=p.native_card(self.profiles['steel-c45'],self.source_map)
model=next(r['data']['model'] for r in result['card']['properties'] if r['data']['kind']=='elasticity')
self.assertEqual(model['young_modulus_pa'],210e9)
self.assertAlmostEqual(model['young_modulus_pa']/(2*(1+model['poisson_ratio'])),80.76923076923077e9)
def test_derived_poisson_is_not_presented_as_measured(self):
result=p.native_card(self.profiles['c11000'],self.source_map)
elastic=next(r for r in result['card']['properties'] if r['data']['kind']=='elasticity')
self.assertIn('derived',elastic['conditions']['state'])
self.assertAlmostEqual(elastic['data']['model']['poisson_ratio'],17000/(2*6400)-1)
def test_derived_value_without_receipt_refuses(self):
r=copy.deepcopy(self.row('c11000','poisson_ratio'));del r['derivation']
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
def test_wood_moisture_density_not_dry_mass_specific_gravity(self):
r=self.row('wood-white-oak','density')
self.assertAlmostEqual(r['value'],761.6)
self.assertNotEqual(r['value'],680)
self.assertEqual(r['conditions']['moisture_dry_basis_kg_kg'],.12)
def test_wood_flexure_not_isotropic_young_modulus(self):
result=p.native_card(self.profiles['wood-white-oak'],self.source_map)
self.assertNotIn('elasticity',{r['data']['kind'] for r in result['card']['properties']})
self.assertNotIn('compressive_strength',{r['data']['kind'] for r in result['card']['properties']})
self.assertIn('flexural_modulus',{r['quantity'] for r in result['not_projected']})
def test_print_directions_and_uncertainty_are_preserved(self):
profile=self.profiles['pla-printed']
strengths=[x for x in profile['properties'] if x['quantity']=='tensile_strength']
self.assertEqual({x['conditions']['direction'] for x in strengths},{'XY','Z'})
self.assertTrue(all(x['uncertainty'] is not None for x in strengths))
self.assertNotIn('tensile_strength',{r['data']['kind'] for r in p.native_card(profile,self.source_map)['card']['properties']})
def test_finite_strain_stress_never_becomes_elastic_modulus(self):
profile=self.profiles['silicone-ds20']
self.assertEqual(self.row('silicone-ds20','stress_at_strain')['conditions']['engineering_strain'],1)
self.assertNotIn('young_modulus',{r['quantity'] for r in profile['properties']})
def test_source_conflicts_stay_quarantined(self):
profile=self.profiles['abs-printed']
self.assertTrue(profile['quarantined_source_ids'])
self.assertNotIn('density',{r['quantity'] for r in profile['properties']})
with self.assertRaises(p.Invalid):p.prepare('abs-printed',True)
def test_fr4_frequency_and_cte_regimes_stay_distinct(self):
profile=self.profiles['fr4-370hr']
eps=[r for r in profile['properties'] if r['quantity']=='relative_permittivity']
self.assertEqual(len({r['conditions']['frequency_hz'] for r in eps}),5)
z=[r for r in profile['properties'] if r['quantity']=='thermal_expansion' and r['conditions']['direction']=='Z']
self.assertEqual({r['conditions']['thermal_regime'] for r in z},{'pre-Tg','post-Tg'})
self.assertNotIn('elasticity',{r['data']['kind'] for r in p.native_card(profile,self.source_map)['card']['properties']})
def test_silica_and_sapphire_are_not_the_same_material_model(self):
self.assertTrue(self.profiles['fused-silica']['isotropic_reference_model'])
self.assertFalse(self.profiles['sapphire']['isotropic_reference_model'])
self.assertNotIn('thermal_expansion',{r['data']['kind'] for r in p.native_card(self.profiles['sapphire'],self.source_map)['card']['properties']})
def test_references_do_not_relicense_supplier_publications(self):
self.assertIsNone(self.source_map['isola-370hr']['license'])
self.assertIsNone(self.source_map['schott-borofloat']['license'])
def test_simulant_bulk_and_grain_density_remain_distinct(self):
self.assertEqual(self.row('lms-1','density')['value'],1560)
self.assertEqual(self.row('lms-1','grain_density')['value'],2920)
self.assertIn('NOT measured lunar soil',self.profiles['lms-1']['reference_state'])
def test_coating_preserves_substrate_and_has_no_invented_density(self):
result=p.resolve('SURF-045')
self.assertEqual(result['binding']['physical_role'],'layer')
self.assertTrue(result['binding']['preserve_existing_material'])
self.assertFalse(result['binding']['auto_assign_body'])
with self.assertRaises(p.Invalid):p.prepare('az93-coating',True)
def test_no_preparation_without_explicit_reference_acknowledgement(self):
with self.assertRaises(p.Invalid):p.prepare('steel-c45',False)
result=p.prepare('steel-c45',True)
self.assertFalse(result['executed']);self.assertFalse(result['assigns_bodies'])
self.assertEqual(result['commands'][0]['params']['density_g_cm3'],7.8)
self.assertEqual(result['commands'][0]['command'],'material.create')
self.assertNotIn('appearance',result['commands'][0]['params'])
def test_unresolved_ids_fail_not_fallback_to_generic_material(self):
for id in ('MAT-999','SURF-999','__proto__',''):
with self.assertRaises(p.Invalid):p.resolve(id)
def test_false_ready_certification_and_zero_unknown_claims_refuse(self):
self.mutated(0,lambda d:d.update(runtime_assignment=True))
self.mutated(0,lambda d:d['profiles'][0].update(certified_design_allowables=True))
self.mutated(2,lambda d:d['catalog'][0].update(unknown_is_zero=True))
self.mutated(2,lambda d:d['catalog'][0].update(auto_assign_body=True))
def test_duplicate_profiles_sources_properties_refuse(self):
self.mutated(0,lambda d:d['profiles'].append(d['profiles'][0]))
self.mutated(1,lambda d:d['sources'].append(d['sources'][0]))
self.mutated(0,lambda d:d['profiles'][0]['properties'].append(d['profiles'][0]['properties'][0]))
def test_catalog_surface_drift_and_missing_records_refuse(self):
self.mutated(2,lambda d:d['catalog'].pop())
self.mutated(2,lambda d:d['surfaces'].pop())
self.mutated(2,lambda d:d['surfaces'][0].update(physical_binding_ids=['MAT-003']))
self.mutated(2,lambda d:d['inputs']['catalog'].update(sha256='0'*64))
self.mutated(2,lambda d:d['inputs']['catalog'].update(path='../../secret'))
def test_undefined_property_source_and_profile_refuse(self):
self.mutated(0,lambda d:d['profiles'][0]['properties'][0].update(source_id='absent'))
self.mutated(2,lambda d:d['catalog'][0]['references'][0].update(profile_id='absent'))
def test_nonfinite_frequency_and_unknown_conditions_refuse(self):
r=copy.deepcopy(self.row('fr4-370hr','relative_permittivity'))
r['conditions']['frequency_hz']=float('nan')
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
r=copy.deepcopy(self.row('fr4-370hr','relative_permittivity'));r['conditions']['temperature']=20
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
def test_negative_and_impossible_fraction_refuse(self):
for id,q,value in [('steel-c45','density',-1),('lms-1','porosity',2)]:
r=copy.deepcopy(self.row(id,q));r['value']=value
r['original']={'value':value,'unit':r['unit'],'scale_to_si':1.,'offset_to_si':0.}
with self.assertRaises(p.Invalid):p.check_property(r,self.source_map)
def test_native_projection_has_bounded_unique_kinds(self):
for profile in self.profiles.values():
card=p.native_card(profile,self.source_map)['card']
self.assertLessEqual(len(card['properties']),16)
kinds=[r['data']['kind'] for r in card['properties']]
self.assertEqual(len(kinds),len(set(kinds)))
self.assertTrue(all(len(r['conditions']['state'].encode())<=1024 for r in card['properties']))
def test_authority_bytes_and_exports_are_deterministic(self):
first=p.make_exports();second=p.make_exports()
self.assertEqual(p.encoded(first),p.encoded(second))
self.assertFalse(first['coverage.json']['numerically_complete_catalog_claim'])
def test_bounded_input_and_array_top_level_refuse(self):
with tempfile.TemporaryDirectory() as folder:
path=Path(folder)/'input.json';path.write_text('[]')
with self.assertRaises(p.Invalid):p.read(path)
with path.open('wb') as stream:stream.truncate(p.MAX_BYTES+1)
with self.assertRaises(p.Invalid):p.read(path)
def test_empty_native_projection_is_explicit_not_reported_ready(self):
for id in ('fr4-370hr','az93-coating','mdf-premier-18'):
result=p.native_card(self.profiles[id],self.source_map)
self.assertEqual(result['native_projection_status'],'extended_data_only')
self.assertFalse(result['card']['properties'])
self.assertTrue(result['not_projected'])
def test_wrong_chemistry_is_not_a_convenient_density_fallback(self):
by_id={row['catalog_id']:row for row in self.bindings['catalog']}
for id,wrong in [('MAT-145','hdpe'),('MAT-248','borofloat-33'),('MAT-439','mdf-premier-18')]:
self.assertNotIn(wrong,{r['profile_id'] for r in by_id[id]['references']})
self.assertNotIn('c11000',{r['profile_id'] for r in by_id['MAT-398']['references']})
def test_no_reference_profile_is_duplicated_with_two_roles(self):
for row in self.bindings['catalog']:
ids=[r['profile_id'] for r in row['references']]
self.assertEqual(len(ids),len(set(ids)),row['catalog_id'])
def test_incomplete_coverage_is_not_reported_numerically_complete(self):
c=p.make_exports()['coverage.json']
self.assertEqual(c['nonempty_native_cards']+c['extended_only_profiles'],c['profile_count'])
self.assertEqual(c['concepts_with_reference_candidates']+c['concepts_needing_specific_recipe'],600)
self.assertFalse(c['numerically_complete_catalog_claim'])
self.assertEqual(c['surfaces_with_reference_candidates'],48)
def test_cured_resin_state_survives_native_projection(self):
result=p.native_card(self.profiles['sikafloor161-cured'],self.source_map)
row=next(r for r in result['card']['properties'] if r['data']['kind']=='compressive_strength')
self.assertIn('28 days',row['conditions']['state'])
self.assertEqual(row['conditions']['temperature_k'],296.15)
self.assertNotIn('density',{r['data']['kind'] for r in result['card']['properties']})
def test_distinct_elastic_conditions_cannot_be_mixed(self):
for field,value in [('state','other temper'),('moisture_dry_basis_kg_kg',.1),('strain_rate_per_s',1.0)]:
profile=copy.deepcopy(self.profiles['steel-c45'])
nu=next(r for r in profile['properties'] if r['quantity']=='poisson_ratio')
nu['conditions'][field]=value
with self.subTest(field=field),self.assertRaises(p.Invalid):
p.native_card(profile,self.source_map)
def test_new_reference_ranges_and_fibre_axes_are_not_flattened(self):
pmma=p.native_card(self.profiles['pmma-goodfellow-sheet'],self.source_map)
self.assertNotIn('elasticity',{r['data']['kind'] for r in pmma['card']['properties']})
fibre=p.native_card(self.profiles['kevlar49-fibre'],self.source_map)
self.assertNotIn('elasticity',{r['data']['kind'] for r in fibre['card']['properties']})
self.assertNotIn('tensile_strength',{r['data']['kind'] for r in fibre['card']['properties']})
self.assertNotIn('thermal_expansion',{r['data']['kind'] for r in fibre['card']['properties']})
def test_named_coating_candidates_do_not_invent_bulk_density(self):
for id in ('c71-enamel','hmg-stoving-hammer','hmg-sc601-clear','uv22-coating'):
profile=self.profiles[id]
self.assertNotIn('density',{r['quantity'] for r in profile['properties']})
with self.assertRaises(p.Invalid):p.prepare(id,True)
def test_para_aramid_not_assigned_as_meta_aramid_honeycomb(self):
row=next(r for r in self.bindings['catalog'] if r['catalog_id']=='MAT-482')
self.assertNotIn('kevlar49-fibre',{r['profile_id'] for r in row['references']})
if __name__=='__main__':unittest.main()