@vnejs/plugins.views.achievement 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/plugins.views.achievement",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "tsconfig.json"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "npx @vnejs/monorepo test",
     "build": "npx @vnejs/monorepo package",
     "publish:major:plugin": "npm run publish:major",
     "publish:minor:plugin": "npm run publish:minor",
@@ -41,6 +41,16 @@
     "@vnejs/uis.utils": "~0.1.0"
   },
   "devDependencies": {
-    "@vnejs/configs.ts-common": "~0.1.0"
+    "@vnejs/configs.ts-common": "~0.1.0",
+    "@vnejs/configs.vitest": "~0.1.0",
+    "@vnejs/test-utils": "~0.1.0",
+    "@vnejs/contracts.canvas.layer": "~0.1.0",
+    "@vnejs/contracts.views.achievement": "~0.1.0",
+    "@vnejs/helpers": "~0.1.0",
+    "@vnejs/module.core": "~0.1.0",
+    "@vnejs/module.components": "~0.1.0",
+    "@vnejs/shared": "~0.1.0",
+    "@vnejs/uis.react": "~0.1.0",
+    "@vnejs/uis.utils": "~0.1.0"
   }
 }

package/src/tests/achievement.test.ts

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { Achievement } from "../modules/achievement.js";
+import { createAchievementTestModule, registerAchievementPluginVne, STORAGE_EVENTS, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("Achievement", () => {
+  beforeEach(() => {
+    registerAchievementPluginVne();
+  });
+
+  it("UNLOCK stores value and emits UNLOCKED and APPEND for new achievement", async () => {
+    const { observer } = createAchievementTestModule(Achievement);
+    const unlocked = spyEvent(observer, SUBSCRIBE_EVENTS.UNLOCKED);
+    const append = spyEvent(observer, SUBSCRIBE_EVENTS.APPEND);
+    const storageSet = spyEvent(observer, STORAGE_EVENTS.SET);
+
+    await observer.emit(SUBSCRIBE_EVENTS.UNLOCK, { id: "kekw" });
+
+    expect(unlocked).toHaveBeenCalledExactlyOnceWith({ id: "kekw" });
+    expect(storageSet).toHaveBeenCalledOnce();
+    expect(append).toHaveBeenCalledExactlyOnceWith({ id: "kekw" });
+  });
+
+  it("UNLOCK skips APPEND when already unlocked and isSkipIfPossible", async () => {
+    const { observer, storage } = createAchievementTestModule(Achievement);
+    const append = spyEvent(observer, SUBSCRIBE_EVENTS.APPEND);
+
+    storage.set("kekw", 1);
+
+    await observer.emit(SUBSCRIBE_EVENTS.UNLOCK, { id: "kekw", isSkipIfPossible: true });
+
+    expect(append).not.toHaveBeenCalled();
+  });
+
+  it("CLEAR removes all storage for module", async () => {
+    const { observer } = createAchievementTestModule(Achievement);
+    const rmAll = spyEvent(observer, STORAGE_EVENTS.RM_ALL);
+
+    await observer.emit(SUBSCRIBE_EVENTS.CLEAR);
+
+    expect(rmAll).toHaveBeenCalledExactlyOnceWith({ module: "achievement" });
+  });
+});

package/src/tests/exec.test.ts

@@ -0,0 +1,55 @@
+import { CONSTANTS as SCENARIO_CONST } from "@vnejs/contracts.core.scenario";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { AchievementExec } from "../modules/exec.js";
+import { createAchievementTestModule, registerAchievementPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("AchievementExec", () => {
+  beforeEach(() => {
+    registerAchievementPluginVne();
+  });
+
+  it("line exec unlock emits UNLOCK", async () => {
+    const { module, observer } = createAchievementTestModule(AchievementExec, { subscribe: false });
+    const unlock = spyEvent(observer, SUBSCRIBE_EVENTS.UNLOCK);
+
+    await (module as AchievementExec).init();
+    await (module as AchievementExec).onLineExec({ line: 'unlock kekw', keywords: [] });
+
+    expect(unlock).toHaveBeenCalledExactlyOnceWith({ id: "kekw", isSkipIfPossible: false });
+  });
+
+  it("line exec with skip_if_possible keyword passes isSkipIfPossible", async () => {
+    const { module, observer } = createAchievementTestModule(AchievementExec, { subscribe: false });
+    const unlock = spyEvent(observer, SUBSCRIBE_EVENTS.UNLOCK);
+
+    await (module as AchievementExec).onLineExec({
+      line: 'unlock kekw',
+      keywords: [SCENARIO_CONST.LINE_KEYWORDS.SKIP_IF_POSSIBLE],
+    });
+
+    expect(unlock).toHaveBeenCalledExactlyOnceWith({ id: "kekw", isSkipIfPossible: true });
+  });
+
+  it("line load unlock emits LOAD", async () => {
+    const { module, observer } = createAchievementTestModule(AchievementExec, { subscribe: false });
+    const load = spyEvent(observer, SUBSCRIBE_EVENTS.LOAD);
+
+    await (module as AchievementExec).onLineLoad({ line: 'unlock kekw' });
+
+    expect(load).toHaveBeenCalledOnce();
+  });
+
+  it("line exec calls emitNext", async () => {
+    const { module, observer } = createAchievementTestModule(AchievementExec, { subscribe: false });
+    const next = vi.fn();
+
+    observer.subscribe("vne:scenario:next", next);
+
+    await (module as AchievementExec).onLineExec({ line: 'unlock kekw' });
+
+    expect(next).toHaveBeenCalledOnce();
+  });
+});

package/src/tests/logs.test.ts

@@ -0,0 +1,23 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+import { SUBSCRIBE_EVENTS as LOGS_EVENTS } from "@vnejs/contracts.core.logs";
+
+import { AchievementLogs } from "../modules/logs.js";
+import { createAchievementTestModule, registerAchievementPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("AchievementLogs", () => {
+  beforeEach(() => {
+    registerAchievementPluginVne();
+  });
+
+  it("UNLOCKED emits log with unlocked action", async () => {
+    const { observer } = createAchievementTestModule(AchievementLogs);
+    const log = spyEvent(observer, LOGS_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.UNLOCKED, { id: "kekw" });
+
+    expect(log).toHaveBeenCalledOnce();
+    expect(log.mock.calls[0][0]).toMatchObject({ module: "achievement.logs", value: { action: "unlocked", id: "kekw" } });
+  });
+});

package/src/tests/setup.ts

@@ -0,0 +1,50 @@
+import { CONSTANTS as LAYER_CONST, PLUGIN_NAME as LAYER, SETTINGS_KEYS as LAYER_SETTINGS } from "@vnejs/contracts.canvas.layer";
+import { SUBSCRIBE_EVENTS as MEDIA_EVENTS } from "@vnejs/contracts.core.media";
+import { SUBSCRIBE_EVENTS as STORAGE_EVENTS } from "@vnejs/contracts.core.storage";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.achievement";
+import {
+  createTestModule as baseCreateTestModule,
+  registerCoreVne,
+  registerVnePlugin,
+  stubEvent,
+  stubSilentEvent,
+} from "@vnejs/test-utils";
+
+export const registerAchievementPluginVne = () => {
+  registerCoreVne();
+  registerVnePlugin(LAYER, { constants: LAYER_CONST, settings: LAYER_SETTINGS });
+  registerVnePlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS });
+};
+
+export const createAchievementTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
+  ModuleClass: T,
+  options: Parameters<typeof baseCreateTestModule>[1] = {},
+) => {
+  const storage = new Map<string, unknown>();
+
+  const result = baseCreateTestModule(ModuleClass, {
+    state: {
+      "achievement.controller": { array: [], isShow: false },
+      ...(options.state ?? {}),
+    },
+    shared: {
+      settings: { [LAYER_SETTINGS.QUALITY]: LAYER_CONST.QUALITIES.FHD },
+      ...(options.shared ?? {}),
+    },
+    ...options,
+  });
+
+  stubEvent(result.observer, STORAGE_EVENTS.GET, ({ key }: { key?: string } = {}) => storage.get(key ?? ""));
+  stubSilentEvent(result.observer, STORAGE_EVENTS.SET, ({ key, value }: { key?: string; value?: unknown } = {}) => {
+    storage.set(key ?? "", value);
+  });
+  stubSilentEvent(result.observer, STORAGE_EVENTS.RM_ALL, () => storage.clear());
+  stubEvent(result.observer, MEDIA_EVENTS.LOAD, () => ({ src: "icon.png" }));
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.APPEND);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.UPDATE);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.LOAD);
+
+  return { ...result, storage };
+};
+
+export { SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, STORAGE_EVENTS };

package/tsconfig.json

@@ -6,5 +6,5 @@
     "jsx": "react-jsx"
   },
   "include": ["src/**/*.ts", "src/**/*.tsx"],
-  "exclude": ["dist", "node_modules"]
+  "exclude": ["dist", "node_modules", "src/tests"]
 }