@latticexyz/recs 2.0.12-main-9be2bb86 → 2.0.12-main-e43c0938

package/src/deprecated/createActionSystem.spec.ts

@@ -1,501 +0,0 @@
-import { deferred, sleep } from "@latticexyz/utils";
-import { ReplaySubject } from "rxjs";
-import { defineComponent, getComponentValueStrict, withValue, setComponent } from "../Component";
-import { createEntity } from "../Entity";
-import { runQuery, HasValue } from "../Query";
-import { createWorld } from "../World";
-import { Type } from "../constants";
-import { World, Component } from "../types";
-import { waitForComponentValueIn } from "./waitForComponentValueIn";
-import { ActionState } from "./constants";
-import { createActionSystem } from "./createActionSystem";
-import { waitForActionCompletion } from "./waitForActionCompletion";
-
-describe("ActionSystem", () => {
-  let world: World;
-  let Resource: Component<{ amount: Type.Number }>;
-  let Action: Component<{
-    state: Type.String;
-    on: Type.OptionalEntity;
-    metadata: Type.OptionalT;
-    overrides: Type.OptionalStringArray;
-    txHash: Type.OptionalString;
-  }>;
-  let actions: ReturnType<typeof createActionSystem>;
-  let txReduced$: ReplaySubject<string>;
-
-  beforeEach(async () => {
-    world = createWorld();
-    txReduced$ = new ReplaySubject<string>();
-    actions = createActionSystem(world, txReduced$, async () => {
-      // mimic wait for tx
-      await sleep(100);
-    });
-    Action = actions.Action;
-    Resource = defineComponent(world, { amount: Type.Number });
-  });
-
-  afterEach(() => {
-    world.dispose();
-  });
-
-  it("should immediately execute actions if their requirement is met and set the Action component", async () => {
-    const mockFn = jest.fn();
-    const entity = actions.add({
-      id: "action",
-      components: {},
-      requirement: () => true,
-      updates: () => [],
-      execute: () => {
-        mockFn();
-      },
-    });
-
-    expect(mockFn).toHaveBeenCalledTimes(1);
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Executing);
-    await waitForActionCompletion(Action, entity);
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Complete);
-  });
-
-  it("should not execute actions if their requirement is not met and set the Action component", () => {
-    const mockFn = jest.fn();
-    const entity = actions.add({
-      id: "action",
-      components: {},
-      requirement: () => false,
-      updates: () => [],
-      execute: () => {
-        mockFn();
-      },
-    });
-
-    expect(mockFn).toHaveBeenCalledTimes(0);
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Requested);
-  });
-
-  it("should set the Action component of failed actions", async () => {
-    const [, reject, promise] = deferred<void>();
-    const entity = actions.add({
-      id: "action",
-      components: {},
-      requirement: () => true,
-      updates: () => [],
-      execute: () => promise,
-    });
-
-    reject(new Error("action failed"));
-
-    await waitForActionCompletion(Action, entity);
-
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Failed);
-  });
-
-  it("should set the Action component of cancelled actions", async () => {
-    const entity = actions.add({
-      id: "action",
-      components: {},
-      requirement: () => false,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    const cancelled = actions.cancel("action");
-    await waitForActionCompletion(Action, entity);
-
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Cancelled);
-    expect(cancelled).toBe(true);
-  });
-
-  it("should not be possible to cancel actions that are already executing", async () => {
-    const [resolve, , promise] = deferred<void>();
-    const entity = actions.add({
-      id: "action",
-      components: {},
-      requirement: () => true,
-      updates: () => [],
-      execute: () => promise,
-    });
-
-    const cancelled = actions.cancel("action");
-    resolve();
-    await waitForActionCompletion(Action, entity);
-    expect(getComponentValueStrict(Action, entity).state).toBe(ActionState.Complete);
-    expect(cancelled).toBe(false);
-  });
-
-  it("should execute actions if components it depends on changed and the requirement is met now", () => {
-    const mockFn = jest.fn();
-    const player = createEntity(world, [withValue(Resource, { amount: 0 })]);
-
-    actions.add({
-      id: "action",
-      components: { Resource },
-      requirement: ({ Resource }) => getComponentValueStrict(Resource, player).amount > 100,
-      updates: () => [],
-      execute: () => {
-        mockFn();
-      },
-    });
-
-    expect(mockFn).toHaveBeenCalledTimes(0);
-    setComponent(Resource, player, { amount: 99 });
-    expect(mockFn).toHaveBeenCalledTimes(0);
-    setComponent(Resource, player, { amount: 101 });
-    expect(mockFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("should return all actions related to a given entity", () => {
-    const settlement1 = createEntity(world);
-    const settlement2 = createEntity(world);
-
-    const entity1 = actions.add({
-      id: "action1",
-      on: settlement1,
-      components: { Resource },
-      requirement: () => false,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    const entity2 = actions.add({
-      id: "action2",
-      on: settlement2,
-      components: { Resource },
-      requirement: () => false,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    const entity3 = actions.add({
-      id: "action3",
-      components: { Resource },
-      requirement: () => false,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    expect(runQuery([HasValue(Action, { on: settlement1 })])).toEqual(new Set([entity1]));
-    expect(runQuery([HasValue(Action, { on: settlement2 })])).toEqual(new Set([entity2]));
-    expect(runQuery([HasValue(Action, { state: ActionState.Requested })])).toEqual(
-      new Set([entity1, entity2, entity3]),
-    );
-  });
-
-  it("should not remove pending update until all corresponding tx have been reduced", async () => {
-    const player = createEntity(world, [withValue(Resource, { amount: 100 })]);
-
-    const entity1 = actions.add({
-      id: "action1",
-      components: { Resource },
-      requirement: () => true,
-      updates: ({ Resource }) => [
-        {
-          component: Resource,
-          entity: player,
-          value: { amount: getComponentValueStrict(Resource, player).amount - 1 },
-        },
-      ],
-      execute: async () => Promise.resolve("tx1"),
-    });
-
-    const entity2 = actions.add({
-      id: "action2",
-      components: { Resource },
-      // Resource needs to be 100 in order for this action to be executed
-      requirement: ({ Resource }) => getComponentValueStrict(Resource, player).amount === 100,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    await waitForComponentValueIn(Action, entity1, [{ state: ActionState.WaitingForTxEvents }]);
-    // While action1 is waiting for tx, action 2 is not executed yet
-    expect(getComponentValueStrict(Action, entity1).state).toBe(ActionState.WaitingForTxEvents);
-    expect(getComponentValueStrict(Action, entity2).state).toBe(ActionState.Requested);
-
-    txReduced$.next("tx1");
-    // Now it's done
-    await waitForComponentValueIn(Action, entity1, [{ state: ActionState.Complete }]);
-    expect(getComponentValueStrict(Action, entity1).state).toBe(ActionState.Complete);
-    await sleep(0);
-    expect(getComponentValueStrict(Action, entity2).state).toBe(ActionState.Complete);
-  });
-
-  // TODO: get tests to pass
-  it.skip("should execute actions if the requirement is met while taking into account pending updates", async () => {
-    const requirementSpy1 = jest.fn();
-    const requirementSpy2 = jest.fn();
-    const requirementSpy3 = jest.fn();
-
-    const executeSpy1 = jest.fn();
-    const executeSpy2 = jest.fn();
-    const executeSpy3 = jest.fn();
-
-    const player = createEntity(world, [withValue(Resource, { amount: 0 })]);
-
-    let nonce = 0;
-
-    // First schedule action1
-    const [resolveAction1, , action1Promise] = deferred<void>();
-    const entity1 = actions.add({
-      id: "action1",
-      components: { Resource },
-      // This action requires a resource amount of 100 to be executed
-      requirement: ({ Resource }) => {
-        requirementSpy1();
-        return getComponentValueStrict(Resource, player).amount >= 100;
-      },
-      // When this action is executed it will subtract 100 from the resource amount
-      updates: ({ Resource }) => [
-        {
-          component: Resource,
-          entity: player,
-          value: { amount: getComponentValueStrict(Resource, player).amount - 100 },
-        },
-      ],
-      execute: async () => {
-        executeSpy1(nonce++);
-        await action1Promise;
-        const { amount } = getComponentValueStrict(Resource, player);
-        setComponent(Resource, player, { amount: amount - 100 });
-      },
-    });
-
-    // Action1 is not executed yet because requirement is not met
-    expect(executeSpy1).toHaveBeenCalledTimes(0);
-
-    // The requirement was checked once when adding the action
-    expect(requirementSpy1).toHaveBeenCalledTimes(1);
-
-    // Then shedule action3
-    actions.add({
-      id: "action3",
-      components: { Resource },
-      // This action also requires a resource amount of 100 to be executed
-      requirement: ({ Resource }) => {
-        requirementSpy3();
-        const amount = getComponentValueStrict(Resource, player).amount;
-        return amount >= 100;
-      },
-      updates: ({ Resource }) => [
-        {
-          component: Resource,
-          entity: player,
-          value: { amount: getComponentValueStrict(Resource, player).amount - 100 },
-        },
-      ],
-      execute: () => {
-        executeSpy3(nonce++);
-      },
-    });
-
-    // Action3 is also not executed yet because the requirement is not met
-    expect(executeSpy3).toHaveBeenCalledTimes(0);
-
-    // The requirement was cheecked once when adding the action
-    expect(requirementSpy3).toHaveBeenCalledTimes(1);
-
-    // Action 1's requirement was not checked again, because neither pending updates nor components changed.
-    expect(requirementSpy1).toHaveBeenCalledTimes(1);
-
-    // Now schedule action2.
-    // This action declares it will update the Resource component to be 100
-    const [resolveAction2, , action2Promise] = deferred<void>();
-    const entity2 = actions.add({
-      id: "action2",
-      components: { Resource },
-      requirement: () => {
-        requirementSpy2();
-        return true;
-      },
-      updates: () => [{ component: Resource, entity: player, value: { amount: 100 } }],
-      execute: async () => {
-        executeSpy2(nonce++);
-        await action2Promise;
-        const { amount } = getComponentValueStrict(Resource, player);
-        setComponent(Resource, player, { amount: amount + 100 });
-      },
-    });
-
-    // action2 is executed immediately
-    expect(executeSpy2).toHaveBeenCalledTimes(1);
-    expect(executeSpy2).toHaveBeenCalledWith(0);
-
-    // But it is not done yet, because the promise is not resolved
-    await waitForComponentValueIn(Action, entity2, [{ state: ActionState.Executing }]);
-    expect(getComponentValueStrict(Action, entity2).state).toBe(ActionState.Executing);
-
-    // action 2's requirement was checked only once
-    expect(requirementSpy2).toHaveBeenCalledTimes(1);
-
-    // Executing action 2 added pending updates and thereby triggered rechecking the requirements of action 1 and action 3
-    expect(requirementSpy1).toHaveBeenCalledTimes(2);
-    expect(requirementSpy3).toHaveBeenCalledTimes(2);
-
-    // Action 1 is already executed before action 2 resolves because it trusts action 2's update declaration
-    expect(executeSpy1).toHaveBeenCalledTimes(1);
-
-    // Action 1 should be executed after action 2
-    expect(executeSpy1).toHaveBeenCalledWith(1);
-
-    // action 3 should not have been executed, because action 1 declared it will reduce the resource amount, such that action3's requirement is not met
-    expect(executeSpy3).toHaveBeenCalledTimes(0);
-
-    // Now resolve action2
-    resolveAction2();
-    await waitForActionCompletion(Action, entity2);
-
-    // The real component amount should be at 100 now
-    expect(getComponentValueStrict(Resource, player).amount).toBe(100);
-
-    // Removing action 2's pending updates and modifying the component state should have triggered two requirement checks on action 3
-    expect(requirementSpy3).toHaveBeenCalledTimes(4);
-
-    // action3 should still not have been executed because action2 is not resolved yet and declared an update
-    expect(executeSpy3).toHaveBeenCalledTimes(0);
-
-    // Now resolve action1
-    resolveAction1();
-    await waitForActionCompletion(Action, entity1);
-
-    // The real component amount should be at 0 now
-    expect(getComponentValueStrict(Resource, player).amount).toBe(0);
-
-    // Removing action 1's pending updates and modifying the component state should have triggered two requirement checks on action 3
-    expect(requirementSpy3).toHaveBeenCalledTimes(6);
-
-    // action3 should still not have been executed
-    expect(executeSpy3).toHaveBeenCalledTimes(0);
-
-    // Setting the resource amount to 100 should trigger a requirement check on action 3
-    setComponent(Resource, player, { amount: 100 });
-    expect(requirementSpy3).toHaveBeenCalledTimes(7);
-
-    // Now action3 should finally have been executed
-    expect(executeSpy3).toHaveBeenCalledTimes(1);
-    expect(executeSpy3).toHaveBeenCalledWith(2);
-
-    // In total action 1's requirements should have been checked 2 times
-    expect(requirementSpy1).toHaveBeenCalledTimes(2);
-
-    // In total action 2's requirements should have been checked 1 time
-    expect(requirementSpy2).toHaveBeenCalledTimes(1);
-
-    // In total action 3's requirements should have been checked 7 times
-    expect(requirementSpy3).toHaveBeenCalledTimes(7);
-  });
-
-  it("declaring component updates should not modify real components", async () => {
-    const player = createEntity(world, [withValue(Resource, { amount: 0 })]);
-
-    expect(getComponentValueStrict(Resource, player)).toEqual({ amount: 0 });
-
-    const [resolve, , promise] = deferred<void>();
-    const entity = actions.add({
-      id: "action",
-      components: { Resource },
-      requirement: () => true,
-      updates: () => [{ component: Resource, entity: player, value: { amount: 1000 } }],
-      execute: async () => {
-        await promise;
-      },
-    });
-
-    expect(getComponentValueStrict(Resource, player)).toEqual({ amount: 0 });
-
-    resolve();
-    await waitForActionCompletion(Action, entity);
-
-    expect(getComponentValueStrict(Resource, player)).toEqual({ amount: 0 });
-  });
-
-  // TODO: get tests to pass
-  it.skip("should rerun the requirement function only if a component value accessed in the requirement changed", () => {
-    const player = createEntity(world, [withValue(Resource, { amount: 0 })]);
-    const requirementSpy = jest.fn();
-
-    actions.add({
-      id: "action",
-      components: { Resource },
-      requirement: ({ Resource }) => {
-        requirementSpy();
-        return getComponentValueStrict(Resource, player).amount >= 100;
-      },
-      updates: () => [],
-      execute: async () => void 0,
-    });
-
-    // The requirement should be checked once when adding the action
-    expect(requirementSpy).toHaveBeenCalledTimes(1);
-
-    // Setting unrelated values in the component should not retrigger a requirement check
-    const player2 = createEntity(world, [withValue(Resource, { amount: 0 })]);
-    setComponent(Resource, player2, { amount: 10 });
-    expect(requirementSpy).toHaveBeenCalledTimes(1);
-
-    // Setting a relevant value in the component should trigger a requirement check
-    setComponent(Resource, player, { amount: 10 });
-    expect(requirementSpy).toHaveBeenCalledTimes(2);
-  });
-
-  // TODO: get tests to pass
-  it.skip("should rerun the requirement function only if a pending update relevant to a value accessed in the requirement changed", () => {
-    const player1 = createEntity(world, [withValue(Resource, { amount: 0 })]);
-    const player2 = createEntity(world);
-
-    const requirementSpy = jest.fn();
-
-    actions.add({
-      id: "action1",
-      components: { Resource },
-      requirement: ({ Resource }) => {
-        requirementSpy();
-        return getComponentValueStrict(Resource, player1).amount >= 100;
-      },
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    // The requirement should be checked once when adding the action
-    expect(requirementSpy).toHaveBeenCalledTimes(1);
-
-    // Another action is executed, which does not declare any updates
-    actions.add({
-      id: "action2",
-      components: { Resource },
-      requirement: () => true,
-      updates: () => [],
-      execute: () => void 0,
-    });
-
-    // Executing actions with no pending updates that don't modify component states should not trigger a requirement check
-    expect(requirementSpy).toHaveBeenCalledTimes(1);
-
-    // Another action declares an update to the resource amount of player2, which is unrelated to action1's requirement
-    actions.add({
-      id: "action3",
-      components: { Resource },
-      requirement: () => true,
-      updates: () => [{ component: Resource, entity: player2, value: { amount: 1000 } }],
-      execute: () => void 0,
-    });
-
-    // Unrelated pending updates should not retrigger a requirement check
-    expect(requirementSpy).toHaveBeenCalledTimes(1);
-
-    const [resolve, , promise] = deferred<void>();
-    // Another action declares an update to the resource amount of player1, which is relevant to action1's requirement
-    actions.add({
-      id: "action4",
-      components: { Resource },
-      requirement: () => true,
-      updates: () => [{ component: Resource, entity: player1, value: { amount: 10000 } }],
-      execute: async () => {
-        await promise;
-      },
-    });
-
-    // Relevant pending updates should trigger a requirement check
-    expect(requirementSpy).toHaveBeenCalledTimes(2);
-    resolve();
-  });
-});