feuerwerk/tests/core/serialize.test.ts

import { describe, expect, it } from 'vitest';
import {
  CreateAssetCommand,
  SetAssetPropertyCommand,
  SetMachineScopeCommand,
} from '../../src/core/commands/assetCommands';
import { SetOverrideCommand } from '../../src/core/commands/sceneObjectCommands';
import { SetVariableScopeCommand } from '../../src/core/commands/variableCommands';
import { deserializeProject, serializeProject } from '../../src/core/store/serialize';
import { makeBehavior, makeSpriteScene, place, roundTrip } from '../helpers';

describe('serialize', () => {
  it('round-trips a project', () => {
    const f = makeSpriteScene();
    const box = place(f, f.spriteId, { x: 7, y: 8 });
    f.stack.execute(new SetOverrideCommand(f.sceneId, box, 'width', 33));
    expect(roundTrip(f.project)).toEqual(f.project);
  });

  /** A behavior's own rows are not the common ones: coercing against those alone dropped the value. */
  it('keeps a behavior running in the editor across a save', () => {
    const f = makeSpriteScene();
    const behavior = makeBehavior(f, 'B');
    f.stack.execute(new SetAssetPropertyCommand(behavior.id, 'runInEditor', true));
    const loaded = roundTrip(f.project).assets.find((a) => a.id === behavior.id)!;
    expect(loaded.props.runInEditor).toBe(true);
  });

  it('round-trips the scope of a variable and of a state machine', () => {
    const f = makeSpriteScene();
    const behavior = makeBehavior(f, 'B', ['score']);
    f.stack.execute(new SetVariableScopeCommand(behavior.id, 'score', 'global'));
    const machine = new CreateAssetCommand('statemachine', 'M');
    f.stack.execute(machine);
    f.stack.execute(new SetMachineScopeCommand(machine.asset.id, 'global'));
    expect(roundTrip(f.project)).toEqual(f.project);
  });

  /** `local` is the absence of the field, so a project made before scopes existed saves back byte-alike. */
  it('writes no scope for a local variable and reads an unknown one as local', () => {
    const f = makeSpriteScene();
    const behavior = makeBehavior(f, 'B', ['score']);
    expect(JSON.stringify(serializeProject(f.project))).not.toContain('scope');

    const loaded = deserializeProject({
      assets: [
        {
          id: behavior.id,
          type: 'behavior',
          name: 'B',
          variables: [{ key: 'score', kind: 'number', scope: 'planet' }],
        },
        { id: 'm1', type: 'statemachine', name: 'M', scope: 'planet' },
      ],
    });
    const reloaded = loaded.assets[0]!;
    const machine = loaded.assets[1]!;
    if (reloaded.type !== 'behavior' || machine.type !== 'statemachine') throw new Error('wrong types');
    expect(reloaded.variables[0]!.scope).toBeUndefined();
    expect(machine.scope).toBeUndefined();
  });

  it('repairs broken documents', () => {
    const project = deserializeProject(
      {
        name: 'Broken',
        activeSceneId: 'missing',
        assets: [
          {
            id: 's1',
            type: 'scene',
            name: 'Scene',
            props: { backgroundColor: '#000000', junk: 1 },
            objects: [
              {
                id: 'o1',
                assetId: 'sp1',
                position: { x: '5', y: null },
                overrides: { color: '#00ff00', width: -3, foo: 1 },
              },
              { id: 'o2', assetId: 'nope', position: {} },
              { id: 'o3', assetId: 's1', position: {} },
            ],
          },
          { id: 'sp1', type: 'sprite', props: { width: 10 } },
          // An asset type this build does not know (a newer document, a renamed type).
          { id: 'x', type: 'sound' },
          { type: 'camera' },
        ],
      },
      'fallback-id',
    );
    expect(project.id).toBe('fallback-id');
    expect(project.activeSceneId).toBe('s1');
    expect(project.assets.map((a) => a.id)).toEqual(['s1', 'sp1']);
    const scene = project.assets[0]!;
    expect(scene.type === 'scene' && scene.props).toEqual({ backgroundColor: 0 });
    const objects = scene.type === 'scene' ? scene.objects : [];
    expect(objects).toHaveLength(1);
    expect(objects[0]).toEqual({
      id: 'o1',
      assetId: 'sp1',
      name: '',
      position: { x: 5, y: 0, z: 0 },
      editorOffset: { x: 0, y: 0 },
      overrides: { color: 0x00ff00, width: 1 },
      parentId: '',
      instanceEdits: {},
    });
    expect(project.assets[1]!.name).toBe('sprite');
    expect(project.assets[1]!.props).toEqual({
      enabled: true,
      scale: 1,
      rotation: 0,
      mirrorX: false,
      mirrorY: false,
      width: 10,
      height: 100,
      color: 0xffffff,
      texture: '',
      shader: '',
    });
  });
});