@nocobase/flow-engine 2.0.0-alpha.3 → 2.0.0-alpha.30

package/src/executor/__tests__/flowExecutor.test.ts

@@ -81,7 +81,7 @@ describe('FlowExecutor', () => {
     expect(result.step2).toBe('step2-ok');
   });
 
-  it('runAutoFlows executes only auto flows in sort order and caches result', async () => {
+  it("dispatchEvent('beforeRender') executes flows in sort order and caches result (when options specify)", async () => {
     const calls: string[] = [];
     const mkFlow = (key: string, sort: number) => ({
       sort,
@@ -104,15 +104,21 @@ describe('FlowExecutor', () => {
 
     const model = createModelWithFlows('m-auto', flows);
 
-    const r1 = await engine.executor.runAutoFlows(model);
-    expect(r1).toHaveLength(2);
+    const r1 = await engine.executor.dispatchEvent(model, 'beforeRender', undefined, {
+      sequential: true,
+      useCache: true,
+    });
+    expect(Array.isArray(r1)).toBe(true);
     // sort order: f1 then f2
     expect(calls).toEqual(['f1', 'f2']);
 
     // second run should hit cache and not execute handlers again
     const prevCount = calls.length;
-    const r2 = await engine.executor.runAutoFlows(model);
-    expect(r2).toEqual(r1);
+    const r2 = await engine.executor.dispatchEvent(model, 'beforeRender', undefined, {
+      sequential: true,
+      useCache: true,
+    });
+    expect(Array.isArray(r2)).toBe(true);
     expect(calls.length).toBe(prevCount);
   });
 
@@ -133,6 +139,146 @@ describe('FlowExecutor', () => {
     expect(submitHandler).not.toHaveBeenCalled();
   });
 
+  it('dispatchEvent default parallel does not stop on exitAll', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, opts?: { exitAll?: boolean }) => ({
+      on: { eventName: 'par' },
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation((ctx) => {
+            calls.push(key);
+            if (opts?.exitAll) ctx.exitAll();
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      a: mkFlow('a', { exitAll: true }),
+      b: mkFlow('b'),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-par', flows);
+
+    await engine.executor.dispatchEvent(model, 'par');
+
+    // 在并行模式下，b 不会被 exitAll 中断
+    expect(calls.sort()).toEqual(['a', 'b']);
+  });
+
+  it('dispatchEvent sequential respects sort order and stops on errors', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, sort: number, opts?: { throw?: boolean }) => ({
+      on: { eventName: 'seq2' },
+      sort,
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation(() => {
+            calls.push(key);
+            if (opts?.throw) throw new Error('boom');
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      f2: mkFlow('f2', 2),
+      f1: mkFlow('f1', 1, { throw: true }),
+      f3: mkFlow('f3', 3),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-seq2', flows);
+    await engine.executor.dispatchEvent(model, 'seq2', {}, { sequential: true });
+
+    // 顺序：按 sort 执行；f1 抛错后终止，f2 和 f3 不会执行
+    expect(calls).toEqual(['f1']);
+  });
+
+  it('dispatchEvent caches non-beforeRender when useCache=true', async () => {
+    const handler = vi.fn();
+    const flows = {
+      onFoo: { on: 'foo', steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-evt-cache', flows);
+
+    await engine.executor.dispatchEvent(model, 'foo', {}, { useCache: true });
+    await engine.executor.dispatchEvent(model, 'foo', {}, { useCache: true });
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatchEvent('beforeRender') runs once due to cache (when options specify)", async () => {
+    const handler = vi.fn();
+    const flows = {
+      auto1: { steps: { s: { handler } } }, // 无 on → 视为 beforeRender
+      auto2: { on: 'beforeRender', steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-br-cache', flows);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    // 两次触发但步骤处理只执行一次（命中缓存）
+    expect(handler).toHaveBeenCalledTimes(2); // 每个 flow 各 1 次，共 2 次
+  });
+
+  it('dispatchEvent supports sequential execution order and exitAll break', async () => {
+    const calls: string[] = [];
+    const mkFlow = (key: string, sort: number, opts?: { exitAll?: boolean }) => ({
+      on: { eventName: 'seq' },
+      sort,
+      steps: {
+        only: {
+          handler: vi.fn().mockImplementation((ctx) => {
+            calls.push(key);
+            if (opts?.exitAll) ctx.exitAll();
+          }),
+        },
+      },
+    });
+
+    const flows = {
+      f1: mkFlow('f1', 1, { exitAll: true }),
+      f2: mkFlow('f2', 2),
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-seq', flows);
+
+    await engine.executor.dispatchEvent(model, 'seq', {}, { sequential: true });
+
+    // f1 executed then exitAll stops f2
+    expect(calls).toEqual(['f1']);
+  });
+
+  it("dispatchEvent('beforeRender') caches results (key includes eventName) when options specify", async () => {
+    const handler = vi.fn().mockResolvedValue('ok');
+    const flows = {
+      f1: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+    const model = createModelWithFlows('m-br', flows);
+
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+    await engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true, useCache: true });
+
+    // handler only executed once because of cache
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatchEvent('beforeRender') rejects when a step throws", async () => {
+    const handler = vi.fn().mockImplementation(() => {
+      throw new Error('boom-br');
+    });
+    const flows = {
+      bad: { steps: { s: { handler } } },
+    } satisfies Record<string, Omit<FlowDefinitionOptions, 'key'>>;
+
+    const model = createModelWithFlows('m-br-reject', flows);
+
+    await expect(engine.executor.dispatchEvent(model, 'beforeRender', undefined, { sequential: true })).rejects.toThrow(
+      'boom-br',
+    );
+  });
+
   it('instance flow overrides global flow with same key', async () => {
     class MyModel extends FlowModel {}