Files
vibemake/tests/grouped-assembly.test.js

108 lines
6.1 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { Vector3, Group } from 'three';
import { validatePackage, visibleAssemblyParts } from '../js/experience-packages.js';
import { AssemblyViewer } from '../js/assembly-viewer.js';
import { ASSEMBLY_PACE } from '../js/assembly-animation.js';
const fixture = () => ({ schemaVersion:1, kind:'assembly', unit:'meter', playback:'grouped-v1',
files:[{path:'part.glb',bytes:1,sha256:'a'.repeat(64)}],
parts:[{id:'base'}, {id:'bolt',parentId:'base'}, {id:'arm'}, {id:'nut'}].map(p=>({...p,file:'part.glb',installOffset:[0,.03,0]})),
groups:[{id:'leg',parts:['base','bolt']},{id:'hand',parts:['arm']}],
steps:[{id:'a',groupId:'leg',parts:['base']},{id:'b',groupId:'leg',parts:['bolt']},{id:'c',groupId:'hand',parts:['arm']},
{id:'j1',type:'join',groupId:'leg',parts:['base','bolt'],installOffset:[.1,0,0]},
{id:'j2',type:'join',groupId:'hand',parts:['arm'],installOffset:[0,.1,0]}, {id:'d',parts:['nut']}],
});
const validate = raw => validatePackage(raw,'assembly','https://example.com/manifest.json');
test('isolates local builds, reveals only joined components, supports arbitrary backward/forward jumps and whole view',()=>{
const pkg=validate(fixture());
for (const [step,expected] of [[1,['base','bolt']],[2,['arm']],[4,['base','bolt','arm']], [0,['base']],
[3,['base','bolt']],[5,['base','bolt','arm','nut']],[null,['base','bolt','arm','nut']],[2,['arm']]]) {
assert.deepEqual([...visibleAssemblyParts(pkg,step)],expected);
}
});
test('keeps generated head views and distinguishes unverified presentation joins',()=>{
const raw=fixture();raw.parts[0].focusDirection=[0,1,0];raw.steps[3].pathStatus='presentation';
const pkg=validate(raw);
assert.deepEqual(pkg.parts[0].focusDirection,[0,1,0]);assert.equal(pkg.steps[3].pathStatus,'presentation');
raw.parts[0].focusDirection=[0,0,0];assert.throws(()=>validate(raw));
});
test('camera settles before installation and remains stationary while the part moves',()=>{
const v=Object.create(AssemblyViewer.prototype), part=new Group(), camera=new Group();
part.position.set(0,1,0);
v.camera=camera;v.controls={target:new Vector3(),update(){return false;}};
v.renderer={shadowMap:{},domElement:{style:{}},render(){}};v.notifyMotion=()=>{};v.loop={invalidate(){}};
const original=globalThis.matchMedia;globalThis.matchMedia=()=>({matches:false});
camera.position.set(0,0,2);
try {v.moveCamera({position:new Vector3(1,1,2),target:new Vector3(0,.5,0)},true);}
finally {globalThis.matchMedia=original;}
v.transitions=[{instance:part,from:part.position.clone(),target:new Vector3(),duration:1,elapsed:0}];
const duration=v.cameraTransition.motionDuration;
v.render(.2);assert.equal(part.position.y,1);assert.ok(camera.position.length()>0);
v.render(duration-.2);assert.equal(part.position.y,1);
assert.ok(v.cameraTransition,'hold the settled shot briefly before insertion');
v.render(ASSEMBLY_PACE.cameraHold);assert.equal(part.position.y,1);assert.equal(v.cameraTransition,null);
const shot=camera.position.clone();v.render(.2);
assert.ok(part.position.y<1);assert.deepEqual(camera.position.toArray(),shot.toArray());
v.render(1);assert.equal(part.position.y,0);
});
test('rejects unfinished, repeated, partial and out-of-order components, and cross-group parenting',()=>{
const cases=[
x=>x.steps.splice(1,1),
x=>x.steps[3].parts=['base'],
x=>x.steps.splice(4,0,{...x.steps[3],id:'duplicate'}),
x=>[x.steps[0],x.steps[2]]=[x.steps[2],x.steps[0]],
x=>x.steps.splice(3,0,x.steps.pop()),
x=>x.parts[2].parentId='base',
x=>delete x.playback,
x=>x.steps[4].installOffset=[0,NaN,0],
x=>x.groups[1].parts.push('bolt'),
x=>x.steps.splice(4,1),
];
for(const mutate of cases) {const x=fixture();mutate(x);assert.throws(()=>validate(x));}
});
for (const protocol of ['grouped-v1','scoped-v1']) test(protocol+': real player replays joins rigidly, never repeats screw operations, restores final poses on seek and whole view',()=>{
const original=globalThis.matchMedia;
globalThis.matchMedia=()=>({matches:false});
try {
const v=Object.create(AssemblyViewer.prototype);
const raw=fixture();
if(protocol==='scoped-v1') {
raw.playback=protocol;
raw.groups.push({id:'finish',parts:['nut']});raw.steps[5].groupId='finish';
const scopes=[['base'],['base','bolt'],['arm'],['base','bolt'],['base','bolt','arm'],['base','bolt','arm','nut']];
raw.steps.forEach((step,index)=>step.visibleParts=scopes[index]);
}
v.config=validate(raw);
v.config.parts[1].installation={type:'screw'}; // Joining must not start another screw operation.
v.parts=new Map(v.config.parts.map(p=>[p.id,new Group()]));
v.parts.get('base').add(v.parts.get('bolt'));
v.transitions=[];v.stepIndex=null;
v.renderer={shadowMap:{},render(){}};v.controls={update(){return false;}};v.loop={invalidate(){}};
v.resetView=()=>{};v.notifyMotion=()=>{};v.refreshCloseup=()=>{};
const visible=()=>[...v.parts].filter(([,p])=>p.visible).map(([id])=>id);
v.setStep(3,true);
assert.equal(v.closeupEnabled,true,'entering a join also enables the following installation closeups');
assert.equal(v.transitions.length,1);
assert.deepEqual(v.parts.get('base').position.toArray(),[.1,0,0]);
assert.deepEqual(v.parts.get('bolt').position.toArray(),[0,0,0]);
v.parts.get('base').updateMatrixWorld(true);
assert.deepEqual(v.parts.get('bolt').getWorldPosition(new Vector3()).toArray(),[.1,0,0]);
v.render(2);
assert.deepEqual(v.parts.get('base').position.toArray(),[0,0,0]);
v.setStep(2,false);assert.deepEqual(visible(),['arm']);
assert.equal(v.closeupEnabled,true);
v.setCloseup(false,{restore:false});
v.setStep(4,true);assert.deepEqual(visible(),['base','bolt','arm']);
assert.equal(v.closeupEnabled,false,'respect manual camera mode across steps');
v.setStep(0,false);assert.deepEqual(visible(),['base']);
v.setStep(null,false);assert.deepEqual(visible(),['base','bolt','arm','nut']);
for(const part of v.parts.values()) assert.deepEqual(part.position.toArray(),[0,0,0]);
} finally {globalThis.matchMedia=original;}
});