feuerwerk/tests/core/holders.test.ts

/**
 * Container assets hold placed objects just like scenes do. Anything that walks "all placed
 * objects" has to cover both – the tests here pin the places that used to look at scenes only.
 * The history tests pin that a rejected undo leaves the stacks usable.
 */
import { describe, expect, it } from 'vitest';
import { type Command, CommandError } from '../../src/core/commands/Command';
import { CommandStack } from '../../src/core/commands/CommandStack';
import { CreateContainerCommand } from '../../src/core/commands/containerCommands';
import { SetOverrideCommand } from '../../src/core/commands/sceneObjectCommands';
import { RemoveVariableCommand, RenameVariableCommand } from '../../src/core/commands/variableCommands';
import type { ContainerAsset } from '../../src/core/model/Asset';
import { findAsset, findUsages, objectHolders } from '../../src/core/model/Project';
import { makeBehavior, makeSpriteScene, place } from '../helpers';

/** A behavior with a `speed` variable, placed and overridden to 42, then wrapped in a container. */
function containerWithOverride() {
  const f = makeSpriteScene();
  const behavior = makeBehavior(f, 'B', ['speed']);
  const objectId = place(f, behavior.id, { x: 0, y: 0 });
  f.stack.execute(new SetOverrideCommand(f.sceneId, objectId, 'speed', 42));
  const container = new CreateContainerCommand(f.sceneId, [objectId]);
  f.stack.execute(container);
  const template = () => (findAsset(f.project, container.assetId) as ContainerAsset).objects[0]!;
  return { ...f, behaviorId: behavior.id, objectId, template };
}

describe('object holders', () => {
  it('counts scenes and container assets alike', () => {
    const { project } = containerWithOverride();
    expect(
      objectHolders(project)
        .map((h) => h.type)
        .sort(),
    ).toEqual(['container', 'scene']);
  });

  it('finds usages inside container templates, not just in scenes', () => {
    const { project, behaviorId, template } = containerWithOverride();
    // The placed object and the template copy the container was built from.
    expect(findUsages(project, behaviorId)).toHaveLength(2);
    expect(template().overrides.speed).toBe(42);
  });
});

describe('RemoveVariableCommand', () => {
  it('clears the override on container templates too, and puts it back on undo', () => {
    const { stack, behaviorId, objectId, sceneOf, template } = containerWithOverride();
    const placed = () => sceneOf().objects.find((o) => o.id === objectId)!;

    stack.execute(new RemoveVariableCommand(behaviorId, 'speed'));
    expect(placed().overrides.speed).toBeUndefined();
    expect(template().overrides.speed).toBeUndefined();

    stack.undo();
    expect(placed().overrides.speed).toBe(42);
    expect(template().overrides.speed).toBe(42);
  });
});

describe('RenameVariableCommand', () => {
  it('renames the override on container templates too', () => {
    const { stack, behaviorId, template } = containerWithOverride();
    stack.execute(new RenameVariableCommand(behaviorId, 'speed', 'velocity'));
    expect(template().overrides.speed).toBeUndefined();
    expect(template().overrides.velocity).toBe(42);

    stack.undo();
    expect(template().overrides.speed).toBe(42);
    expect(template().overrides.velocity).toBeUndefined();
  });
});

/** Applies a marker to the project; its undo refuses to run. */
class RefusingUndo implements Command {
  readonly label = 'Refusing';
  execute(project: { name: string }): void {
    project.name = 'executed';
  }
  undo(): void {
    throw new CommandError('target is gone');
  }
}

describe('CommandStack', () => {
  it('keeps a command on the undo stack when its undo is rejected', () => {
    const { project, stack } = makeSpriteScene();
    stack.execute(new RefusingUndo());
    expect(stack.canUndo).toBe(true);

    expect(() => stack.undo()).toThrow(CommandError);
    // Not swallowed by the history: still undoable, and not queued for redo.
    expect(stack.canUndo).toBe(true);
    expect(stack.canRedo).toBe(false);
    expect(project.name).toBe('executed');
  });

  it('keeps a command on the redo stack when its redo is rejected', () => {
    const project = { formatVersion: 1, id: 'p', name: 'P', assets: [], activeSceneId: '' };
    const stack = new CommandStack(project);
    let failing = false;
    stack.execute({
      label: 'Toggle',
      execute: () => {
        if (failing) throw new CommandError('nope');
      },
      undo: () => {},
    });
    stack.undo();
    failing = true;

    expect(() => stack.redo()).toThrow(CommandError);
    expect(stack.canRedo).toBe(true);
    expect(stack.canUndo).toBe(false);
  });
});