feuerwerk/tests/core/dynamic-ports.test.ts

/** Ports a node grows from its own settings (`NodeDef.derivePorts`), and what happens to the edges when it shrinks. */
import { describe, expect, it } from 'vitest';
import { AddPortCommand } from '../../src/core/commands/portCommands';
import { SetNodeParamCommand } from '../../src/core/commands/graphCommands';
import {
  BEHAVIOR_END,
  BEHAVIOR_START,
  findNode,
  type GraphNode,
  GraphInterpreter,
  inlineInputs,
  requireNodeDef,
  resolveDef,
} from '../../src/core/graph';
import { behaviorLookup } from '../../src/core/model/behaviorPrograms';
import type { BehaviorAsset } from '../../src/core/model/Asset';
import { fakeContext, graphEditor, makeBehavior, makeProject, type ProjectFixture } from '../helpers';

function sequenceFixture() {
  const fixture = makeProject();
  const behavior = makeBehavior(fixture, 'B');
  const edit = graphEditor(fixture, behavior);
  return { ...fixture, behavior, edit };
}

const portsOf = (fixture: ProjectFixture, node: GraphNode) =>
  resolveDef(node, behaviorLookup(fixture.project))!.outputs.map((p) => p.key);

const edgeKeys = (behavior: BehaviorAsset) =>
  behavior.graph.edges.map((e) => `${e.from.port}→${e.to.port}`).sort();

describe('a Sequence sized by its count', () => {
  it('offers three outputs by default and grows one port per step', () => {
    const { stack, project, behavior, edit } = sequenceFixture();
    const node = edit.addNode('Sequence');
    expect(portsOf({ project, stack }, node)).toEqual(['a', 'b', 'c']);
    stack.execute(new SetNodeParamCommand(behavior.id, node.id, 'count', 6));
    expect(portsOf({ project, stack }, findNode(behavior.graph, node.id)!)).toEqual([
      'a',
      'b',
      'c',
      'd',
      'e',
      'f',
    ]);
  });

  it('never falls below two outputs, because one output is a plain link', () => {
    const { stack, project, behavior, edit } = sequenceFixture();
    const node = edit.addNode('Sequence');
    stack.execute(new SetNodeParamCommand(behavior.id, node.id, 'count', 1));
    expect(portsOf({ project, stack }, findNode(behavior.graph, node.id)!)).toEqual(['a', 'b']);
  });

  it('takes the edges of the outputs it drops, and gives them back on undo', () => {
    const { stack, behavior, edit } = sequenceFixture();
    const node = edit.addNode('Sequence', { count: 4 });
    edit.wire(['a', 'b', 'c', 'd'].map((port) => [node, port, edit.addNode('Log'), 'exec'] as const));
    stack.execute(new SetNodeParamCommand(behavior.id, node.id, 'count', 2));
    expect(edgeKeys(behavior)).toEqual(['a→exec', 'b→exec']);
    stack.undo();
    expect(edgeKeys(behavior)).toEqual(['a→exec', 'b→exec', 'c→exec', 'd→exec']);
  });
});

/**
 * The point of a struct: a bundle crosses a behavior boundary on ONE edge. Tetris carries the same
 * state today as eight parallel ports wired by hand, which is the pain this replaces.
 */
describe('a struct travelling through a nested behavior', () => {
  it('goes in as one port and comes back out as its parts', () => {
    const fixture = makeProject();

    const callee = makeBehavior(fixture, 'Sum piece');
    const inner = graphEditor(fixture, callee);
    const start = inner.addNode(BEHAVIOR_START);
    const end = inner.addNode(BEHAVIOR_END);
    fixture.stack.execute(new AddPortCommand(callee.id, start.id, { key: 'piece', kind: 'struct' }));
    fixture.stack.execute(new AddPortCommand(callee.id, end.id, { key: 'total', kind: 'number' }));
    const expand = inner.addNode('ExpandStruct');
    for (const key of ['x', 'y'])
      fixture.stack.execute(new AddPortCommand(callee.id, expand.id, { key, kind: 'number' }));
    const add = inner.addNode('Add');
    inner.wire([
      [start, 'exec', end, 'exec'],
      [start, 'piece', expand, 'value'],
      [expand, 'x', add, 'a'],
      [expand, 'y', add, 'b'],
      [add, 'result', end, 'total'],
    ]);

    const caller = makeBehavior(fixture, 'Caller', ['result']);
    const outer = graphEditor(fixture, caller);
    const pack = outer.addNode('PackStruct', { x: 30, y: 12 });
    for (const key of ['x', 'y'])
      fixture.stack.execute(new AddPortCommand(caller.id, pack.id, { key, kind: 'number' }));
    const onStart = outer.addNode('OnStart');
    const call = outer.addNode('RunBehavior', { behavior: callee.id });
    const set = outer.addNode('SetVariable', { variable: 'result' });
    outer.wire([
      [onStart, 'exec', call, 'exec'],
      [pack, 'value', call, 'piece'],
      [call, 'exec', set, 'exec'],
      [call, 'total', set, 'value'],
    ]);

    // One edge into the call, where two numbers would need two.
    expect(caller.graph.edges.filter((e) => e.to.node === call.id && e.to.port !== 'exec')).toHaveLength(1);
    const ctx = fakeContext({ variables: { result: 0 } });
    new GraphInterpreter(caller.graph, behaviorLookup(fixture.project)).fire('OnStart', ctx);
    expect(ctx.variables.result).toBe(42);
  });
});

describe('a struct input', () => {
  it('is offered no inline field, because a bundle cannot be typed on one line', () => {
    const def = requireNodeDef('ExpandStruct');
    expect(def.inputs.map((p) => p.type)).toEqual(['struct']);
    expect(inlineInputs(def)).toEqual([]);
  });
});

describe('a Run behavior node whose behavior changes', () => {
  it('drops the edges of the ports the new behavior does not have', () => {
    const fixture = makeProject();
    const called = makeBehavior(fixture, 'Called');
    const other = makeBehavior(fixture, 'Other');
    const start = graphEditor(fixture, called).addNode(BEHAVIOR_START);
    fixture.stack.execute(new AddPortCommand(called.id, start.id, { key: 'power', kind: 'number' }));

    const caller = makeBehavior(fixture, 'Caller');
    const edit = graphEditor(fixture, caller);
    const call = edit.addNode('RunBehavior', { behavior: called.id });
    const number = edit.addNode('Number', { value: 3 });
    edit.connect(number, 'value', call, 'power');
    expect(edgeKeys(caller)).toEqual(['value→power']);

    fixture.stack.execute(new SetNodeParamCommand(caller.id, call.id, 'behavior', other.id));
    expect(edgeKeys(caller)).toEqual([]);
    fixture.stack.undo();
    expect(edgeKeys(caller)).toEqual(['value→power']);
    expect(start.ports).toEqual([{ key: 'power', kind: 'number' }]);
  });
});