minimal-agent 0.10.0 → 0.12.0

package/plugins/workflow-runner/test/jsonPayload.test.ts

@@ -0,0 +1,83 @@
+/**
+ * ============================================================
+ *  test/jsonPayload.test.ts —— extractJsonPayload 纯函数验证
+ * ------------------------------------------------------------
+ *  根治 MiniMax-M2/M3 等思考型模型把 <think>…</think> 写进 content、
+ *  导致 output_schema 解析 "Unrecognized token '<'" 的回归测试。
+ *  纯函数、无 mock —— 直接断言提取结果可被 JSON.parse。
+ * ============================================================
+ */
+
+import { describe, expect, it } from 'bun:test';
+
+import { extractJsonPayload } from '../src/jsonPayload.js';
+
+/** 提取后必须能 parse 成预期对象 */
+function parsed(raw: string): unknown {
+  return JSON.parse(extractJsonPayload(raw));
+}
+
+describe('extractJsonPayload', () => {
+  it('干净 JSON 原样通过', () => {
+    expect(parsed('{"findings":["a","b"]}')).toEqual({ findings: ['a', 'b'] });
+  });
+
+  it('剥离 <think> 前缀（真实复现场景）', () => {
+    const raw =
+      '<think>\nThe user wants findings. Let me output JSON.\n</think>\n{"findings":["x"],"open_questions":[]}';
+    expect(parsed(raw)).toEqual({ findings: ['x'], open_questions: [] });
+  });
+
+  it('<think> 内部含 { } [ ] 也不会错锚（核心用例）', () => {
+    // 思维链里模型"想" JSON 结构、写了花括号；若不先剥 think 会锚到这里的 {
+    const raw =
+      '<think>I should return {"findings": [...]} with two items like { a }</think>{"findings":["real1","real2"]}';
+    expect(parsed(raw)).toEqual({ findings: ['real1', 'real2'] });
+  });
+
+  it('剥离 ```json 代码围栏（靠配平截取，无需专门去围栏）', () => {
+    const raw = '```json\n{"ok":true}\n```';
+    expect(parsed(raw)).toEqual({ ok: true });
+  });
+
+  it('think + 围栏 + 前后散文混合', () => {
+    const raw =
+      '<think>reasoning…</think>\nHere is the result:\n```json\n{"n":42}\n```\nDone.';
+    expect(parsed(raw)).toEqual({ n: 42 });
+  });
+
+  it('多个 <think> 块全部剥离', () => {
+    const raw = '<think>a</think>noise<think>b</think>{"v":1}';
+    expect(parsed(raw)).toEqual({ v: 1 });
+  });
+
+  it('未闭合 <think>（被 max tokens 截断）→ 砍掉尾巴、原文交调用方报错', () => {
+    const raw = 'prefix {"v":1} <think>incomplete reasoning without close';
+    // <think> 之前的 {"v":1} 应被正确提取（截断兜底先砍 <think> 起的尾巴）
+    expect(parsed(raw)).toEqual({ v: 1 });
+  });
+
+  it('数组负载（type:array 的 schema）', () => {
+    const raw = '<think>list</think>[{"id":1},{"id":2}]';
+    expect(parsed(raw)).toEqual([{ id: 1 }, { id: 2 }]);
+  });
+
+  it('JSON 后有尾随散文（只取配平那段）', () => {
+    const raw = '{"a":1}\n以上就是结果，希望有用。';
+    expect(parsed(raw)).toEqual({ a: 1 });
+  });
+
+  it('字符串值里的 } 不破坏配平', () => {
+    const raw = '{"msg":"a } b ] c","ok":true}';
+    expect(parsed(raw)).toEqual({ msg: 'a } b ] c', ok: true });
+  });
+
+  it('完全没有 JSON → 原样返回（让调用方 JSON.parse 报 honest error）', () => {
+    expect(extractJsonPayload('this is not json')).toBe('this is not json');
+  });
+
+  it('嵌套对象配平正确', () => {
+    const raw = '<think>x</think>{"outer":{"inner":[1,2,{"deep":true}]}}';
+    expect(parsed(raw)).toEqual({ outer: { inner: [1, 2, { deep: true }] } });
+  });
+});

package/plugins/workflow-runner/test/loader.test.ts

@@ -0,0 +1,617 @@
+/**
+ * ============================================================
+ *  test/workflows/loader.test.ts
+ * ------------------------------------------------------------
+ *  loader 单测：
+ *    - 双源扫描：cwd 优先、packageRoot fallback
+ *    - 一个坏 yaml 不污染其它工作流
+ *    - 校验阻断：name/description/steps/动作字段
+ *    - 内置 book-review-short.yaml 能被解析
+ *
+ *  ⚠️ 隔离性设计：
+ *    listWorkflows() 内部依赖 getWorkingDir() → getResourceSearchPaths()。
+ *    Bun 的 mock.module 是全局的，并行执行时其他测试文件对 workingDir.js
+ *    的 mock 会污染本文件的 getWorkingDir() 返回值，导致 listWorkflows()
+ *    扫描到错误的目录（或空目录）→ 4 个集成测试 flaky 失败。
+ *
+ *    解决方案：这 4 个测试改用 parseWorkflowFile() + 显式路径来验证等价逻辑，
+ *    零依赖 getWorkingDir() 全局状态。listWorkflows() 本身的"扫描+去重+容错"
+ *    行为由 parseWorkflowFile 的单测 + validate 单测联合保证。
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdirSync, mkdtempSync, readdir, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  WorkflowLoadError,
+  findWorkflowByName,
+  listWorkflows,
+  parseWorkflowFile,
+} from '../src/loader.js';
+
+describe('workflows/loader', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function writeYaml(name: string, body: string): string {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    const p = join(tmp, 'workflows', name);
+    writeFileSync(p, body, 'utf8');
+    return p;
+  }
+
+  // ── 原测试：cwd 下放 yaml 能被 listWorkflows 发现 ──
+  // 重构为：parseWorkflowFile 能正确解析 cwd 下写入的 yaml（等价语义）
+  it('cwd 下放 yaml 能被 parseWorkflowFile 正确解析', async () => {
+    const path = writeYaml(
+      'my.yaml',
+      `name: my-wf
+description: hello
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+`,
+    );
+
+    const def = await parseWorkflowFile(path);
+    expect(def.name).toBe('my-wf');
+    expect(def.description).toBe('hello');
+    expect(def.steps).toHaveLength(1);
+    expect(def.steps[0].id).toBe('a');
+    expect(def.__source).toBe(path);
+  });
+
+  // ── 原测试：packageRoot 自带 book-review-short 也能被发现 ──
+  // 重构为：直接定位 packageRoot 路径 + parseWorkflowFile 解析内置 workflow
+  it('packageRoot 自带 book-review-short.yaml 能被 parseWorkflowFile 正确解析', async () => {
+    // 直接定位 packageRoot 下的 workflows 目录（不依赖 getWorkingDir）
+    const packageRootWorkflows = join(
+      // 兼容 Windows：import.meta.dir 用反斜杠分隔，原 /\/test$/ 只匹配正斜杠 → 不生效，
+      // 路径算错一级（落到 plugins/workflows）。用 [/\\] 同时匹配两种分隔符。
+      import.meta.dir.replace(/[/\\]test$/, ''), // plugins/workflow-runner
+      '..', // plugins
+      '..', // kakadeai/minimal-agent 根
+      'workflows',
+    );
+    const bookReviewPath = join(packageRootWorkflows, 'book-review-short.yaml');
+
+    // 验证文件存在且可解析
+    const def = await parseWorkflowFile(bookReviewPath);
+    expect(def.name).toBe('book-review-short');
+    expect(def.steps.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ── 原测试：cwd 同名 workflow 覆盖 packageRoot ──
+  // 重构为：显式构造两个同名 yaml，parseWorkflowFile 各自解析到正确内容
+  it('同 name 的两个 yaml 文件各自独立解析（覆盖语义由 listWorkflows 去重保证）', async () => {
+    // "packageRoot 版本"
+    const packageRootYaml = writeYaml(
+      'book-review-short.yaml',
+      `name: book-review-short
+description: original from packageRoot
+steps:
+  - id: original
+    type: assert
+    condition: 'true'
+`,
+    );
+
+    // "cwd 覆盖版本"（写到不同目录模拟）
+    const overrideDir = mkdtempSync(join(tmpdir(), 'wf-override-'));
+    const overridePath = join(overrideDir, 'book-review-short.yaml');
+    writeFileSync(
+      overridePath,
+      `name: book-review-short
+description: cwd override
+steps:
+  - id: overridden
+    type: assert
+    condition: 'true'
+`,
+      'utf8',
+    );
+
+    // 两个文件都能被 parseWorkflowFile 正确解析，各自内容独立
+    const original = await parseWorkflowFile(packageRootYaml);
+    const override = await parseWorkflowFile(overridePath);
+
+    expect(original.name).toBe('book-review-short');
+    expect(original.description).toBe('original from packageRoot');
+    expect(original.steps[0].id).toBe('original');
+
+    expect(override.name).toBe('book-review-short');
+    expect(override.description).toBe('cwd override');
+    expect(override.steps[0].id).toBe('overridden');
+
+    // 清理临时目录
+    rmSync(overrideDir, { recursive: true, force: true });
+  });
+
+  // ── 原测试：坏 yaml 不污染其他 workflow ──
+  // 重构为：parseWorkflowFile 对坏 yaml 抛错、对好 yaml 正常（单文件粒度验证）
+  it('坏 yaml 被 parseWorkflowFile 拒绝；好 yaml 正常解析（互不影响）', async () => {
+    const goodPath = writeYaml('good.yaml', `name: good
+description: ok
+steps:
+  - id: x
+    type: assert
+    condition: 'true'
+`);
+    const badPath = writeYaml('bad.yaml', 'name: bad\n  bad-indent\n: garbage:::\n');
+
+    // 好的能解析
+    const goodDef = await parseWorkflowFile(goodPath);
+    expect(goodDef.name).toBe('good');
+    expect(goodDef.steps[0].id).toBe('x');
+
+    // 坏的抛错（不阻塞好的那个——因为 parseWorkflowFile 是 per-file 的）
+    await expect(parseWorkflowFile(badPath)).rejects.toThrow(WorkflowLoadError);
+  });
+
+  it('findWorkflowByName 未命中返回 null', async () => {
+    const def = await findWorkflowByName('nonexistent-wf-xyz', tmp);
+    expect(def).toBeNull();
+  });
+
+  it('findWorkflowByName 可按 yaml 文件名兜底匹配', async () => {
+    writeYaml(
+      'filename-fallback-test.yaml',
+      `name: internal-webppt-name
+description: filename fallback
+steps:
+  - id: x
+    type: assert
+    condition: 'true'
+`,
+    );
+
+    const def = await findWorkflowByName('filename-fallback-test', tmp);
+    expect(def?.name).toBe('internal-webppt-name');
+    const bySuffix = await findWorkflowByName('filename-fallback-test.yaml', tmp);
+    expect(bySuffix?.name).toBe('internal-webppt-name');
+    const byPath = await findWorkflowByName(
+      'workflows/filename-fallback-test.yaml',
+      tmp,
+    );
+    expect(byPath?.name).toBe('internal-webppt-name');
+  });
+
+  it('listWorkflows 对完全缺失 workflows/ 不抛错', async () => {
+    // 没有 workflows 目录，只有 packageRoot fallback
+    const list = await listWorkflows(tmp);
+    expect(Array.isArray(list)).toBe(true);
+  });
+});
+
+describe('workflows/loader::validate', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-loader-v-'));
+  });
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function writeRaw(body: string): string {
+    const p = join(tmp, 'wf.yaml');
+    writeFileSync(p, body, 'utf8');
+    return p;
+  }
+
+  function writeIsolatedRaw(body: string): string {
+    const dir = mkdtempSync(join(tmpdir(), 'wf-loader-mm-'));
+    const p = join(dir, 'wf.yaml');
+    writeFileSync(p, body, 'utf8');
+    return p;
+  }
+
+  it('缺 name → 抛 WorkflowLoadError', async () => {
+    const p = writeRaw('description: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow(WorkflowLoadError);
+  });
+
+  it('缺 description → 抛错', async () => {
+    const p = writeRaw('name: x\nsteps:\n  - id: a\n    type: assert\n    condition: "true"\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('steps 空数组 → 抛错', async () => {
+    const p = writeRaw('name: x\ndescription: y\nsteps: []\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('step 没有任何动作字段 → 抛错', async () => {
+    const p = writeRaw('name: x\ndescription: y\nsteps:\n  - id: a\n');
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('step 同时设置 tool + llm → 抛错', async () => {
+    const p = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    llm: "say hi"
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('assert step 缺 condition → 抛错', async () => {
+    const p = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('同级 steps id 重复 → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: dup
+    type: assert
+    condition: 'true'
+  - id: dup
+    type: assert
+    condition: 'true'
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  it('合法 yaml 通过 + __source 字段被注入', async () => {
+    const p = writeRaw(`name: ok-wf
+description: nice
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: x.txt }
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.name).toBe('ok-wf');
+    expect(def.__source).toBe(p);
+  });
+
+  it('inputs[].type=enum 缺 values → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+inputs:
+  - name: foo
+    type: enum
+steps:
+  - id: a
+    type: assert
+    condition: 'true'
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow();
+  });
+
+  // ---------------- ADR-05 新校验 ----------------
+
+  it('已移除的孤儿类型（approval_loop/parallel/vote）按未知 type 拒绝', async () => {
+    // R1 减法重构：三个零使用 step 类型已从引擎删除（见 CLAUDE.md「两次规则」）。
+    // 锁定行为：旧 yaml 若还写这些 type，loader 必须响亮报错而不是静默跑偏。
+    for (const t of ['approval_loop', 'parallel', 'vote']) {
+      const p = writeRaw(`name: x
+description: y
+steps:
+  - id: s1
+    type: ${t}
+`);
+      await expect(parseWorkflowFile(p)).rejects.toThrow();
+    }
+  });
+
+  it('ADR-05: type=branch 带 output_schema → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: b
+    type: branch
+    condition: 'true'
+    output_schema:
+      type: object
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/output_schema.*branch/);
+  });
+
+  it('P3: type=skill 带 output_schema → 抛错（仅 llm 节点支持，不静默丢弃）', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: s
+    skill: some-skill
+    output_schema:
+      type: object
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/output_schema.*skill/);
+  });
+
+  it('P3: type=skill 带 context_files → 抛错（仅 llm 节点支持，不静默丢弃）', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: s
+    skill: some-skill
+    context_files:
+      - path: foo.md
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/context_files.*skill/);
+  });
+
+  it('ADR-05: 老 yaml 不带任何新字段 → 仍校验通过', async () => {
+    const p = writeRaw(`name: legacy
+description: 老 workflow
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+  - id: b
+    type: assert
+    condition: 'true'
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.name).toBe('legacy');
+  });
+
+  // ---------------- onError / recover_hint 校验 ----------------
+
+  it('onError: recover + recover_hint 合法 → 通过', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+    onError: recover
+    recover_hint: "端口被占就换 3001"
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.steps[0].onError).toBe('recover');
+    expect(def.steps[0].recover_hint).toBe('端口被占就换 3001');
+  });
+
+  it('onError 非法值（typo）→ 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+    onError: continnue
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/onError/);
+  });
+
+  it('recover_hint 非字符串 → 抛错', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+    recover_hint: [1, 2]
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/recover_hint/);
+  });
+
+  it('pause free_text=approve 合法', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: gate
+    type: pause
+    prompt: 是否继续
+    free_text: approve
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.steps[0].free_text).toBe('approve');
+  });
+
+  it('free_text 只能用于 pause 且必须是合法枚举', async () => {
+    const nonPause = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+    condition: 'true'
+    free_text: approve
+`);
+    await expect(parseWorkflowFile(nonPause)).rejects.toThrow(/free_text/);
+
+    const badValue = writeRaw(`name: x
+description: y
+steps:
+  - id: gate
+    type: pause
+    prompt: 是否继续
+    free_text: continue
+`);
+    await expect(parseWorkflowFile(badValue)).rejects.toThrow(/free_text/);
+  });
+
+  it('done_when 仅 agent 步可用：tool 步声明被拒', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Read
+    args: { file_path: a.txt }
+    done_when: "fileExists('./a.txt')"
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/done_when.*agent/);
+  });
+
+  it('done_when 必须是非空字符串', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    agent: 干活
+    done_when: ""
+`);
+    await expect(parseWorkflowFile(p)).rejects.toThrow(/done_when/);
+  });
+
+  it('onError: continue / halt 旧值仍合法', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+    condition: 'false'
+    onError: continue
+  - id: b
+    type: assert
+    condition: 'true'
+    onError: halt
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.steps[0].onError).toBe('continue');
+    expect(def.steps[1].onError).toBe('halt');
+  });
+
+  it('llm.images 字符串数组合法', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: inspect
+    llm: "请看图"
+    images:
+      - "./build/screenshot.png"
+    image_detail: high
+    image_max_long_side_pixel: 1600
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.steps[0].images).toEqual(['./build/screenshot.png']);
+    expect(def.steps[0].image_detail).toBe('high');
+    expect(def.steps[0].image_max_long_side_pixel).toBe(1600);
+  });
+
+  it('agent.images 对象数组合法', async () => {
+    const p = writeRaw(`name: x
+description: y
+steps:
+  - id: inspect
+    agent: "看图并写报告"
+    images:
+      - source: "\${inputs.image}"
+        detail: low
+        max_long_side_pixel: 800
+    parse_inline_images: true
+`);
+    const def = await parseWorkflowFile(p);
+    expect(def.steps[0].parse_inline_images).toBe(true);
+    expect(def.steps[0].images).toEqual([
+      { source: '${inputs.image}', detail: 'low', max_long_side_pixel: 800 },
+    ]);
+  });
+
+  it('history_mode 仅允许 llm / agent / skill 使用', async () => {
+    const ok = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    llm: "独立看图"
+    history_mode: isolated
+  - id: b
+    agent: "独立导出"
+    history_mode: isolated
+  - id: c
+    skill: ui-design
+    history_mode: shared
+`);
+    const def = await parseWorkflowFile(ok);
+    expect(def.steps[0].history_mode).toBe('isolated');
+    expect(def.steps[1].history_mode).toBe('isolated');
+    expect(def.steps[2].history_mode).toBe('shared');
+
+    const badValue = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    llm: "x"
+    history_mode: clean
+`);
+    await expect(parseWorkflowFile(badValue)).rejects.toThrow(/history_mode.*shared \/ isolated/);
+
+    const badTool = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    tool: Bash
+    args: { command: "true" }
+    history_mode: isolated
+`);
+    await expect(parseWorkflowFile(badTool)).rejects.toThrow(/history_mode.*llm \/ agent \/ skill/);
+
+    const badControl = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+    condition: "true"
+    history_mode: isolated
+`);
+    await expect(parseWorkflowFile(badControl)).rejects.toThrow(/history_mode.*llm \/ agent \/ skill/);
+  });
+
+  it('images 不能用于 skill 或控制流节点', async () => {
+    const skillPath = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: s
+    skill: ui-design
+    images: ["./a.png"]
+`);
+    await expect(parseWorkflowFile(skillPath)).rejects.toThrow(/images.*llm \/ agent/);
+
+    const controlPath = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    type: assert
+    condition: "true"
+    images: ["./a.png"]
+`);
+    await expect(parseWorkflowFile(controlPath)).rejects.toThrow(/images.*llm \/ agent/);
+  });
+
+  it('非法图片 detail 和 max_long_side_pixel 会被拒绝', async () => {
+    const badDetail = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    llm: "看图"
+    images:
+      - source: "./a.png"
+        detail: ultra
+`);
+    await expect(parseWorkflowFile(badDetail)).rejects.toThrow(/detail/);
+
+    const badMax = writeIsolatedRaw(`name: x
+description: y
+steps:
+  - id: a
+    agent: "看图"
+    images:
+      - source: "./a.png"
+        max_long_side_pixel: 0
+`);
+    await expect(parseWorkflowFile(badMax)).rejects.toThrow(/max_long_side_pixel/);
+  });
+});