@mmapp/player-core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/__tests__/actions.test.ts

@@ -1,187 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ActionDispatcher } from '../actions/dispatcher';
-import { createEvaluator, WEB_FAILURE_POLICIES, clearExpressionCache } from '../expression';
-import type { Evaluator, ExpressionContext } from '../expression/types';
-import type { ActionDefinition } from '../actions/types';
-
-describe('ActionDispatcher', () => {
-  let dispatcher: ActionDispatcher;
-  let evaluator: Evaluator;
-  let ctx: ExpressionContext;
-
-  beforeEach(() => {
-    clearExpressionCache();
-    dispatcher = new ActionDispatcher();
-    evaluator = createEvaluator({
-      functions: [],
-      failurePolicy: WEB_FAILURE_POLICIES.DURING_ACTION,
-    });
-    ctx = {
-      state_data: { count: 5 },
-      memory: {},
-      current_state: 'active',
-      status: 'ACTIVE',
-      count: 5,
-    };
-  });
-
-  describe('register/unregister', () => {
-    it('registers a handler', () => {
-      dispatcher.register('log', () => {});
-      expect(dispatcher.has('log')).toBe(true);
-      expect(dispatcher.size).toBe(1);
-    });
-
-    it('unregisters a handler', () => {
-      dispatcher.register('log', () => {});
-      dispatcher.unregister('log');
-      expect(dispatcher.has('log')).toBe(false);
-    });
-
-    it('clears all handlers', () => {
-      dispatcher.register('a', () => {});
-      dispatcher.register('b', () => {});
-      dispatcher.clear();
-      expect(dispatcher.size).toBe(0);
-    });
-  });
-
-  describe('execute', () => {
-    it('executes actions with registered handlers', async () => {
-      const handler = vi.fn();
-      dispatcher.register('notify', handler);
-
-      const actions: ActionDefinition[] = [
-        { type: 'notify', config: { message: 'hello' } },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(1);
-      expect(results[0].success).toBe(true);
-      expect(results[0].type).toBe('notify');
-      expect(handler).toHaveBeenCalledWith({ message: 'hello' }, ctx);
-    });
-
-    it('returns error result for missing handlers', async () => {
-      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      const actions: ActionDefinition[] = [
-        { type: 'unknown', config: {} },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(1);
-      expect(results[0].success).toBe(false);
-      expect(results[0].error).toContain('No handler');
-      warn.mockRestore();
-    });
-
-    it('captures handler errors without throwing', async () => {
-      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      dispatcher.register('bad', () => { throw new Error('boom'); });
-
-      const actions: ActionDefinition[] = [
-        { type: 'bad', config: {} },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(1);
-      expect(results[0].success).toBe(false);
-      expect(results[0].error).toBe('boom');
-      warn.mockRestore();
-    });
-
-    it('executes actions sequentially', async () => {
-      const order: number[] = [];
-      dispatcher.register('step', async (config) => {
-        order.push(config.n as number);
-      });
-
-      const actions: ActionDefinition[] = [
-        { type: 'step', config: { n: 1 } },
-        { type: 'step', config: { n: 2 } },
-        { type: 'step', config: { n: 3 } },
-      ];
-
-      await dispatcher.execute(actions, ctx);
-      expect(order).toEqual([1, 2, 3]);
-    });
-
-    it('skips actions whose condition evaluates to false', async () => {
-      const handler = vi.fn();
-      dispatcher.register('conditional', handler);
-
-      const actions: ActionDefinition[] = [
-        { type: 'conditional', config: {}, condition: 'gt(count, 100)' },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx, evaluator);
-      expect(results).toHaveLength(0); // skipped, not in results
-      expect(handler).not.toHaveBeenCalled();
-    });
-
-    it('executes actions whose condition evaluates to true', async () => {
-      const handler = vi.fn();
-      dispatcher.register('conditional', handler);
-
-      const actions: ActionDefinition[] = [
-        { type: 'conditional', config: { x: 1 }, condition: 'gt(count, 3)' },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx, evaluator);
-      expect(results).toHaveLength(1);
-      expect(results[0].success).toBe(true);
-    });
-
-    it('skips condition check when no evaluator provided', async () => {
-      const handler = vi.fn();
-      dispatcher.register('nocond', handler);
-
-      const actions: ActionDefinition[] = [
-        { type: 'nocond', config: {}, condition: 'gt(count, 100)' },
-      ];
-
-      // Without evaluator, condition is not checked → action executes
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(1);
-      expect(handler).toHaveBeenCalledOnce();
-    });
-
-    it('handles empty action list', async () => {
-      const results = await dispatcher.execute([], ctx);
-      expect(results).toHaveLength(0);
-    });
-
-    it('continues execution after one action fails', async () => {
-      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      const good = vi.fn();
-      dispatcher.register('bad', () => { throw new Error('fail'); });
-      dispatcher.register('good', good);
-
-      const actions: ActionDefinition[] = [
-        { type: 'bad', config: {} },
-        { type: 'good', config: {} },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(2);
-      expect(results[0].success).toBe(false);
-      expect(results[1].success).toBe(true);
-      expect(good).toHaveBeenCalledOnce();
-      warn.mockRestore();
-    });
-
-    it('handles async handlers', async () => {
-      dispatcher.register('async_action', async (config) => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-      });
-
-      const actions: ActionDefinition[] = [
-        { type: 'async_action', config: {} },
-      ];
-
-      const results = await dispatcher.execute(actions, ctx);
-      expect(results).toHaveLength(1);
-      expect(results[0].success).toBe(true);
-    });
-  });
-});