Zum Inhalt

tests/ui/respawnCoordinator.test.ts

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// Behavioural tests for the respawn coordinator. Verifies that each path
// (nonce, preset switch, seed-param debounce) coalesces correctly and that
// non-seed param edits do NOT cause a respawn (regression for the bug
// where editing moveSpeed re-seeded agents after 250 ms).

import { createRoot } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { BUILT_IN_PRESETS, DEFAULT_PRESET } from '~/presets/builtIn';
import {
  presetState,
  resetEdited,
  selectPreset,
  updateEdited,
  updateSpecies,
} from '~/stores/presetStore';
import { triggerRespawn } from '~/stores/uiStore';
import { createRespawnCoordinator } from '~/ui/respawnCoordinator';

const fakeLocalStorage = () => {
  const store = new Map<string, string>();
  return {
    getItem: (k: string) => store.get(k) ?? null,
    setItem: (k: string, v: string) => {
      store.set(k, v);
    },
    removeItem: (k: string) => {
      store.delete(k);
    },
    clear: () => store.clear(),
    key: () => null,
    length: 0,
  };
};

const otherPreset = () => {
  const p = BUILT_IN_PRESETS.find((x) => x.id !== DEFAULT_PRESET.id);
  if (!p) throw new Error('test setup: need a second built-in preset');
  return p;
};

describe('respawn coordinator', () => {
  let respawnCount = 0;
  let dispose: (() => void) | null = null;

  beforeEach(() => {
    vi.stubGlobal('localStorage', fakeLocalStorage());
    vi.useFakeTimers();
    selectPreset(DEFAULT_PRESET);
    respawnCount = 0;
    dispose = createRoot((d) => {
      createRespawnCoordinator({
        performRespawn: () => {
          respawnCount += 1;
        },
      });
      return d;
    });
  });

  afterEach(() => {
    dispose?.();
    dispose = null;
    vi.useRealTimers();
    vi.unstubAllGlobals();
  });

  it('does NOT respawn when a non-seed species param (moveSpeed) is edited', () => {
    updateSpecies(0, 'moveSpeed', 5);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(0);
  });

  it('does NOT respawn on edits to other non-seed params (decayRate, exposure)', () => {
    updateEdited('decayRate', 0.5);
    updateEdited('exposure', 2);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(0);
  });

  it('debounces a respawn when populationShare is edited', () => {
    updateSpecies(0, 'populationShare', 0.5);
    vi.advanceTimersByTime(200);
    expect(respawnCount).toBe(0);
    vi.advanceTimersByTime(100);
    expect(respawnCount).toBe(1);
  });

  it('debounces a respawn when agentCount is edited', () => {
    updateEdited('agentCount', 50000);
    vi.advanceTimersByTime(250);
    expect(respawnCount).toBe(1);
  });

  it('coalesces rapid edits into one respawn', () => {
    updateEdited('agentCount', 50000);
    vi.advanceTimersByTime(100);
    updateEdited('agentCount', 60000);
    vi.advanceTimersByTime(100);
    updateEdited('agentCount', 70000);
    vi.advanceTimersByTime(250);
    expect(respawnCount).toBe(1);
  });

  it('respawns exactly once on preset switch (no double-respawn from debounce)', () => {
    selectPreset(otherPreset());
    expect(respawnCount).toBe(1);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(1);
  });

  it('respawns immediately on triggerRespawn (no debounce)', () => {
    triggerRespawn();
    expect(respawnCount).toBe(1);
  });

  it('cancels a pending debounce when triggerRespawn fires', () => {
    updateEdited('agentCount', 50000);
    vi.advanceTimersByTime(100);
    expect(respawnCount).toBe(0);
    triggerRespawn();
    expect(respawnCount).toBe(1);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(1);
  });

  it('respawns exactly once on resetEdited (only the nonce path fires)', () => {
    updateEdited('agentCount', 50000);
    vi.advanceTimersByTime(100);
    expect(respawnCount).toBe(0);
    resetEdited();
    expect(respawnCount).toBe(1);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(1);
  });

  it('coalesces a pending debounce when preset is switched mid-edit', () => {
    updateEdited('agentCount', 50000);
    vi.advanceTimersByTime(100);
    expect(respawnCount).toBe(0);
    selectPreset(otherPreset());
    expect(respawnCount).toBe(1);
    vi.advanceTimersByTime(500);
    expect(respawnCount).toBe(1);
  });

  it('fires onPresetSwitch before performRespawn on preset switch', () => {
    const events: string[] = [];
    dispose?.();
    dispose = createRoot((d) => {
      createRespawnCoordinator({
        performRespawn: () => events.push('respawn'),
        onPresetSwitch: () => events.push('switch'),
      });
      return d;
    });
    selectPreset(otherPreset());
    expect(events).toEqual(['switch', 'respawn']);
  });
});