tests: process-store

Author: alexpineda

.gitignore

@@ -1,17 +1,10 @@
-bw-replay-example-bins
-maps
 node_modules
 .env
 .cache
-bwdata
 dist
-.vscode
-ramps
 .DS_Store
 static
 test
-packages/casclib/.gitmodules
-packages/casclib/build
 yarn-error.log
-matches.json
-titan.js
+titan.js
+.vscode

.python-version

@@ -0,0 +1 @@
+3.10.7

.vscode/launch.json

@@ -0,0 +1,34 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug Jest Tests",
+      "type": "node",
+      "request": "launch",
+      "runtimeArgs": [
+        "--inspect-brk",
+        "${workspaceRoot}/node_modules/jest/bin/jest.js",
+        "--runInBand"
+      ],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "skipFiles": ["<node_internals>/**"],
+      "autoAttachChildProcesses": true
+    },
+
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Electron: Main",
+      "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron-webpack",
+      "runtimeArgs": ["dev"],
+      "windows": {
+        "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron-webpack.cmd"
+      },
+      "skipFiles": ["<node_internals>/**"]
+    }
+  ]
+}

src/renderer/core/world/world-composer.ts

@@ -26,10 +26,13 @@ import { TypeEmitter } from "@utils/type-emitter";
 import { World, WorldEvents } from "./world";
 import { borrow, expose, mix } from "@utils/object-utils";
 import { mixer } from "@core/global";
+import processStore from "@stores/process-store";
 // import { useSettingsStore } from "@stores/settings-store";
 
 export const createWorldComposer = async (openBW: OpenBW, assets: Assets, map: Chk, players: BasePlayer[], commands: CommandsStream) => {
 
+    processStore().clearAll();
+
     const janitor = new Janitor("WorldComposer");
     const events = janitor.mop(new TypeEmitter<WorldEvents>(), "events");
     const settings = createReactiveSessionVariables(events);

src/renderer/image/generate-map/chk-to-terrain-mesh.ts

@@ -84,8 +84,6 @@ export async function chkToTerrainMesh(mapWidth: number, mapHeight: number, tile
   janitor.mop(effectsTextures, "effectsTextures");
   //TODO: generate water mask
 
-  genProcess.complete();
-
   renderComposer.preprocessEnd();
 
   const terrain = await createTerrainGeometryFromQuartiles(mapWidth, mapHeight, creepTexture, creepEdgesTexture, geomOptions, dataTextures, heightMaps, textures, effectsTextures);

src/renderer/image/generate-map/create-terrain-geom-from-quartiles.ts

@@ -198,7 +198,6 @@ export const createTerrainGeometryFromQuartiles = async (
         quartileWidth: qw, quartileHeight: qh, tilesX, tilesY
     }
 
-    genProcess.complete();
     return terrain;
 };
 export default createTerrainGeometryFromQuartiles;

src/renderer/scenes/home/space-scene.ts

@@ -132,7 +132,7 @@ let fireTexture: Texture;
 
 export const preloadIntro = async () => {
 
-    const { increment, complete } = processStore().addOrCreate("intro", 4);
+    const { increment } = processStore().addOrCreate("intro", 4);
 
     //TODO submit to types
     //@ts-ignore
@@ -151,8 +151,6 @@ export const preloadIntro = async () => {
 
     battleLights.load(fireTexture);
 
-    complete();
-
 };
 
 let mouse = new Vector3();

src/renderer/scenes/map-scene-loader.ts

@@ -93,8 +93,6 @@ export const mapSceneLoader = async (chkFilepath: string): Promise<SceneState> =
     }
   );
 
-  process.complete();
-
   return {
     id: "@map",
     start: () => {

src/renderer/scenes/replay-scene-loader.ts

@@ -130,8 +130,6 @@ export const replaySceneLoader = async (filepath: string): Promise<SceneState> =
 
   document.title = `Titan Reactor - ${gameTitle}`;
 
-  loadProcess.complete();
-
   return {
     id: "@replay",
     start: () => {

src/renderer/stores/process-store.test.ts

@@ -1,12 +1,137 @@
-import { describe, it } from "@jest/globals";
+import { describe, it, jest } from "@jest/globals";
 import processStore from "./process-store";
+
+jest.mock("@ipc/log");
+
+//TODO: fix this hack
+Object.defineProperty(window.performance, 'mark', {
+    configurable: true,
+    value: jest.fn(),
+});
+
+Object.defineProperty(window.performance, 'clearMeasures', {
+    configurable: true,
+    value: jest.fn(),
+});
+
+Object.defineProperty(window.performance, 'clearMarks', {
+    configurable: true,
+    value: jest.fn(),
+});
+
+Object.defineProperty(window.performance, 'measure', {
+    configurable: true,
+    value: jest.fn(() => ({ duration: 100 })),
+});
+
 describe("ProcessStore", () => {
 
-    it("should have empty processes on init", () => {
+    beforeEach(() => {
+
+        processStore().clearAll();
+
+    });
+
+    it("total should default to 0 with no processes", () => {
 
         expect(processStore().processes).toHaveLength(0);
 
+        expect(processStore().getTotalProgress()).toBe(0);
+
+    });
+
+    it("create should add a process and return a wrapper", () => {
+
+        const wrapper = processStore().create("test", 100);
+
+        expect(processStore().processes).toHaveLength(1);
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        expect(wrapper).toBeDefined();
+
+    });
+
+    it("should increment increment a process", () => {
+
+        const wrapper = processStore().create("test", 2);
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        wrapper.increment();
+
+        expect(processStore().getTotalProgress()).toBe(0.5);
+
+        expect(processStore().isInProgress(wrapper.id)).toBe(true);
+
+        expect(processStore().isComplete(wrapper.id)).toBe(false);
+
     });
 
+    it("should be complete if current === max", () => {
+
+        const wrapper = processStore().create("test", 1);
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        wrapper.increment();
+
+        expect(processStore().getTotalProgress()).toBe(1);
+
+        expect(processStore().isComplete(wrapper.id)).toBe(true);
+
+        expect(processStore().isInProgress(wrapper.id)).toBe(false);
+
+
+    });
+
+    it("should clear completed when asked", () => {
+
+        const wrapper = processStore().create("test", 1);
+        const other = processStore().create("test2", 1);
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        wrapper.increment();
+
+        expect(processStore().getTotalProgress()).toBe(0.5);
+
+        expect(processStore().isComplete(wrapper.id)).toBe(true);
+
+        expect(processStore().isInProgress(wrapper.id)).toBe(false);
+
+        expect(processStore().isComplete(other.id)).toBe(false);
+
+        expect(processStore().isInProgress(other.id)).toBe(true);
+
+        processStore().clearCompleted();
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        expect(processStore().processes).toHaveLength(1);
+
+
+    });
+
+
+    it("should add to an open processwhen asked", () => {
+
+        const wrapper = processStore().create("test", 1);
+        const other = processStore().addOrCreate("test2", 1);
+
+        expect(wrapper.id).toBe(other.id);
+
+        expect(processStore().getTotalProgress()).toBe(0);
+
+        wrapper.increment();
+
+        expect(processStore().getTotalProgress()).toBe(0.5);
+
+        other.increment();
+
+        expect(processStore().getTotalProgress()).toBe(1);
+
+
+    });
 
 });

src/renderer/stores/process-store.ts

@@ -11,12 +11,12 @@ export type IncrementalProcess = {
   current: number;
 };
 
-type ProcessWrapper = { id: string, increment: () => void, complete: () => void, add(additiona: number): void };
+type ProcessWrapper = { id: string, increment: () => void, add(additiona: number): void };
+
 export type ProcessStore = {
   processes: IncrementalProcess[];
   create: (label: string, max: number) => ProcessWrapper;
   increment: (id: string, current?: number) => void;
-  forceComplete: (id: string) => void;
   isComplete: (id: string) => boolean;
   isInProgress: (id: string) => boolean;
   getTotalProgress: () => number;
@@ -32,15 +32,12 @@ export const useProcessStore = create<ProcessStore>((set, get) => ({
   _createProcessWrapper: (id: string, process: IncrementalProcess) => ({
     id,
     increment: () => get().increment(id),
-    complete: () => get().forceComplete(id),
     add: (additional: number) => {
       process.max += additional;
     }
   }),
   create: (label: string, max = PROCESS_MAX) => {
     const id = MathUtils.generateUUID();
-    performance.clearMarks(`process-${id}`);
-    performance.clearMeasures(`process-${id}`);
     log.verbose("@process/init: " + label);
 
     performance.mark(`process-${id}`);
@@ -61,6 +58,7 @@ export const useProcessStore = create<ProcessStore>((set, get) => ({
   addOrCreate: (label: string, max: number) => {
     const existing = get().processes[0];
     if (existing) {
+      performance.mark(`process-${existing.id}`);
       existing.max += max;
       return get()._createProcessWrapper(existing.id, existing);
     } else {
@@ -79,34 +77,13 @@ export const useProcessStore = create<ProcessStore>((set, get) => ({
           (p) => (p.id === id ? { ...p, current: next } : p)
         ),
       }));
-    }
-  },
-  forceComplete: (id: string, clear = true) => {
-    if (get().isComplete(id)) {
-      return;
-    }
-    if (!get().isInProgress(id)) {
-      log.error(`@process/complete: process ${id} is not in progress`);
-      return;
-    }
-
-    const perf = performance.measure(`process-${id}`);
-    performance.clearMarks(`process-${id}`);
-    performance.clearMeasures(`process-${id}`);
 
-    const { label } = get().processes.find((p) => p.id === id)!;
-
-    log.info(`@process/complete: ${label} ${perf.duration}ms`);
-
-    const process = get().processes.find((p) => p.id === id);
-    if (!process) return;
-
-    process.current = process.max;
-
-    if (clear) {
-      set(({ processes }) => ({
-        processes: processes.filter((p) => p.id !== id)
-      }));
+      if (next === process.max) {
+        const perf = performance.measure(`process-${id}`);
+        performance.clearMarks(`process-${id}`);
+        performance.clearMeasures(`process-${id}`);
+        log.info(`@process/complete: ${process.label} ${perf.duration}ms`);
+      }
     }
   },
   clearAll: () => {
@@ -120,7 +97,7 @@ export const useProcessStore = create<ProcessStore>((set, get) => ({
     }));
   },
   isInProgress: (id: string) =>
-    get().processes.some((p) => p.id === id),
+    get().processes.some((p) => p.id === id && p.current < p.max),
   isComplete: (id: string) =>
     get().processes.some((p) => p.id === id && p.current >= p.max),
   getTotalProgress: () => {