@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/tests/AutomationGwtTest.res.mjs

@@ -0,0 +1,189 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "../src/Automation_GWT.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string),
+    shippingAddress: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ShipmentCreated",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let todoItemSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  shippingAddress: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "CreateShipment",
+  orderId: s.m(S.string),
+  address: s.m(S.string)
+}));
+
+function collect(event) {
+  if (event.TAG !== "OrderPlaced") {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        shippingAddress: event.shippingAddress
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "OrderPlaced") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+function process(_id, item) {
+  return [
+    item.orderId,
+    {
+      TAG: "CreateShipment",
+      orderId: item.orderId,
+      address: item.shippingAddress
+    }
+  ];
+}
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let ShipOrderSlice = {
+  name: "ShipOrder",
+  consumedEventSchema: consumedEventSchema,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  collect: collect,
+  resolve: resolve,
+  process: process,
+  commandAuthorization: commandAuthorization
+};
+
+let include = Automation_GWT$ReventlessGwt.Make(ShipOrderSlice);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvent = include.givenEvent;
+
+let whenCollect = include.whenCollect;
+
+let thenTodos = include.thenTodos;
+
+let whenResolve = include.whenResolve;
+
+let thenResolved = include.thenResolved;
+
+let givenTodo = include.givenTodo;
+
+let whenProcess = include.whenProcess;
+
+let thenCommand = include.thenCommand;
+
+let givenEvents = include.givenEvents;
+
+let whenSweep = include.whenSweep;
+
+let thenCommands = include.thenCommands;
+
+let andThenEvents = include.andThenEvents;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+describe("ShipOrder AutomationSlice", () => {
+  test("collect: OrderPlaced creates a pending TODO", () => thenTodos(whenCollect(givenEvent({
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    shippingAddress: "1 Main St"
+  })), [[
+      "o1",
+      {
+        orderId: "o1",
+        shippingAddress: "1 Main St"
+      }
+    ]]));
+  test("resolve: ShipmentCreated marks the TODO done", () => thenResolved(whenResolve(givenEvent({
+    TAG: "ShipmentCreated",
+    orderId: "o1"
+  })), "o1"));
+  test("process: pending TODO emits CreateShipment", () => thenCommand(whenProcess(givenTodo("o1", {
+    orderId: "o1",
+    shippingAddress: "1 Main St"
+  })), "o1", {
+    TAG: "CreateShipment",
+    orderId: "o1",
+    address: "1 Main St"
+  }));
+  test("sweep: events → commands, andThenEvents drains todos", () => {
+    let s = whenSweep(givenEvents([{
+        TAG: "OrderPlaced",
+        orderId: "o1",
+        shippingAddress: "1 Main St"
+      }]));
+    let commandsOk = thenCommands(s, [[
+        "o1",
+        {
+          TAG: "CreateShipment",
+          orderId: "o1",
+          address: "1 Main St"
+        }
+      ]]);
+    let drained = andThenEvents(s, [{
+        TAG: "ShipmentCreated",
+        orderId: "o1"
+      }]);
+    let todosOk = thenScenarioTodos(drained, []);
+    if (commandsOk.TAG === "Ok") {
+      if (todosOk.TAG === "Ok") {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return todosOk;
+      }
+    } else {
+      return commandsOk;
+    }
+  });
+});
+
+let Spec = include.Spec;
+
+let thenNoCommand = include.thenNoCommand;
+
+export {
+  ShipOrderSlice,
+  Spec,
+  describe,
+  test,
+  givenEvent,
+  whenCollect,
+  thenTodos,
+  whenResolve,
+  thenResolved,
+  givenTodo,
+  whenProcess,
+  thenCommand,
+  thenNoCommand,
+  givenEvents,
+  whenSweep,
+  thenCommands,
+  andThenEvents,
+  thenScenarioTodos,
+}
+/* consumedEventSchema Not a pure module */

package/tests/BuildClassifierTest.res

@@ -0,0 +1,133 @@
+// Unit tests for BuildClassifier — the state machine that turns a
+// `rescript build -w` line-stream into buildStart / buildOk / buildFail. The
+// success path is synchronous (the "Finished … compilation" line); the failure
+// path is debounced (no terminator in rescript's error output), so those tests
+// await past the 400ms settle window.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+let delay = (ms: int): promise<unit> =>
+  Promise.make((resolve, _reject) => setTimeout(() => resolve(), ms))
+
+describe("BuildClassifier", () => {
+  testPromise("emits onStart then onOk for a clean incremental compile", async () => {
+    let starts = ref(0)
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => starts := starts.contents + 1,
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("Compiled 1 modules")
+    feed("Finished incremental compilation")
+    expect(starts.contents)->toEqual(1)
+    expect(oks.contents)->toEqual(1)
+    expect(fails.contents->Array.length)->toEqual(0)
+  })
+
+  testPromise("emits onFail with the error text after the output settles", async () => {
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("Compiled 1 modules")
+    feed("We've found a bug for you!")
+    feed("This has type: string")
+    feed("But it's expected to have type: int")
+    await delay(550)
+    expect(oks.contents)->toEqual(0)
+    expect(fails.contents->Array.length)->toEqual(1)
+    let msg = fails.contents->Array.getUnsafe(0)
+    expect(msg->String.includes("This has type: string"))->toEqual(true)
+  })
+
+  testPromise("watchdog fails a build that starts but never terminates", async () => {
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make(~watchdogMs=50, {
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    // No "Finished …" and no error marker — a crashed/hung watcher.
+    await delay(120)
+    expect(oks.contents)->toEqual(0)
+    expect(fails.contents->Array.length)->toEqual(1)
+    let msg = fails.contents->Array.getUnsafe(0)
+    expect(msg->String.includes("watchdog"))->toEqual(true)
+  })
+
+  testPromise("watchdog does not fire once the build finishes", async () => {
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make(~watchdogMs=50, {
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("Finished incremental compilation")
+    await delay(120)
+    expect(oks.contents)->toEqual(1)
+    expect(fails.contents->Array.length)->toEqual(0)
+  })
+
+  testPromise("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    // A crashed toolchain / pnpm resolution failure prints an error block with no
+    // preceding "Parsed …" line. The old `compiling && hasError` guard left this
+    // pinned forever; now `hasError` alone settles it.
+    let oks = ref(0)
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Syntax error: unexpected token")
+    feed("  at Foo.res:3:1")
+    await delay(550)
+    expect(oks.contents)->toEqual(0)
+    expect(fails.contents->Array.length)->toEqual(1)
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Syntax error"))->toEqual(true)
+  })
+
+  testPromise("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = ref([])
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => (),
+      onFail: msg => fails := Array.concat(fails.contents, [msg]),
+    })
+    feed("Parsed 1 source files")
+    feed("We've found a bug for you!")
+    // 30 filler lines push a distinctive later error past the old 20-line window.
+    for i in 1 to 30 {
+      feed("noise line " ++ Int.toString(i))
+    }
+    feed("Found 2 errors")
+    await delay(550)
+    expect(fails.contents->Array.length)->toEqual(1)
+    // The late "Found 2 errors" line survives (dropped under the old cap of 20).
+    expect((fails.contents->Array.getUnsafe(0))->String.includes("Found 2 errors"))->toEqual(true)
+  })
+
+  testPromise("strips ANSI colour codes before matching the finish line", async () => {
+    let oks = ref(0)
+    let feed = BuildClassifier.make({
+      onStart: () => (),
+      onOk: _ms => oks := oks.contents + 1,
+      onFail: _msg => (),
+    })
+    feed("Parsed 2 source files")
+    feed("\x1b[1;32mFinished incremental compilation\x1b[0m")
+    expect(oks.contents)->toEqual(1)
+  })
+})

package/tests/BuildClassifierTest.res.mjs

@@ -0,0 +1,176 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as BuildClassifier$ReventlessGwt from "../src/BuildClassifier.res.mjs";
+
+function delay(ms) {
+  return new Promise((resolve, _reject) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+globalThis.describe("BuildClassifier", () => {
+  globalThis.test("emits onStart then onOk for a clean incremental compile", async () => {
+    let starts = {
+      contents: 0
+    };
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {
+        starts.contents = starts.contents + 1 | 0;
+      },
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("Compiled 1 modules");
+    feed("Finished incremental compilation");
+    globalThis.expect(starts.contents).toEqual(1);
+    globalThis.expect(oks.contents).toEqual(1);
+    globalThis.expect(fails.contents.length).toEqual(0);
+  });
+  globalThis.test("emits onFail with the error text after the output settles", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("Compiled 1 modules");
+    feed("We've found a bug for you!");
+    feed("This has type: string");
+    feed("But it's expected to have type: int");
+    await delay(550);
+    globalThis.expect(oks.contents).toEqual(0);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    let msg = fails.contents[0];
+    globalThis.expect(msg.includes("This has type: string")).toEqual(true);
+  });
+  globalThis.test("watchdog fails a build that starts but never terminates", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(50, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    await delay(120);
+    globalThis.expect(oks.contents).toEqual(0);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    let msg = fails.contents[0];
+    globalThis.expect(msg.includes("watchdog")).toEqual(true);
+  });
+  globalThis.test("watchdog does not fire once the build finishes", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(50, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("Finished incremental compilation");
+    await delay(120);
+    globalThis.expect(oks.contents).toEqual(1);
+    globalThis.expect(fails.contents.length).toEqual(0);
+  });
+  globalThis.test("errors emitted before the first Parsed line still settle to onFail (B3)", async () => {
+    let oks = {
+      contents: 0
+    };
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Syntax error: unexpected token");
+    feed("  at Foo.res:3:1");
+    await delay(550);
+    globalThis.expect(oks.contents).toEqual(0);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Syntax error")).toEqual(true);
+  });
+  globalThis.test("a multi-error build keeps error blocks past the old 20-line cap (B3)", async () => {
+    let fails = {
+      contents: []
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {},
+      onFail: msg => {
+        fails.contents = fails.contents.concat([msg]);
+      }
+    });
+    feed("Parsed 1 source files");
+    feed("We've found a bug for you!");
+    for (let i = 1; i <= 30; ++i) {
+      feed("noise line " + i.toString());
+    }
+    feed("Found 2 errors");
+    await delay(550);
+    globalThis.expect(fails.contents.length).toEqual(1);
+    globalThis.expect(fails.contents[0].includes("Found 2 errors")).toEqual(true);
+  });
+  globalThis.test("strips ANSI colour codes before matching the finish line", async () => {
+    let oks = {
+      contents: 0
+    };
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => {},
+      onOk: _ms => {
+        oks.contents = oks.contents + 1 | 0;
+      },
+      onFail: _msg => {}
+    });
+    feed("Parsed 2 source files");
+    feed("\x1b[1;32mFinished incremental compilation\x1b[0m");
+    globalThis.expect(oks.contents).toEqual(1);
+  });
+});
+
+export {
+  delay,
+}
+/*  Not a pure module */

package/tests/CliRunEntryTest.res

@@ -0,0 +1,57 @@
+// Regression tests for the CLI runner's per-test deadline (A2) and the
+// Collector's skip-depth reset (A4). Before A2 a hung test body wedged the whole
+// run — `runEntry` awaited it with no deadline. Before A4 a throwing `xdescribe`
+// left `skipDepth` > 0, silently skipping every subsequently loaded file; the
+// reset lives in `Collector.activate`.
+
+open JestGlobals
+
+@val external setTimeout: (unit => unit, int) => unit = "setTimeout"
+
+let hangingEntry = (~timeout): Collector.entry => {
+  id: "hangs",
+  name: "hangs forever",
+  describePath: [],
+  slice: None,
+  // A body that never resolves — the pathological hung test.
+  body: () => Promise.make((_resolve, _reject) => ()),
+  status: Collector.Runnable,
+  location: None,
+  timeout,
+}
+
+describe("Cli.runEntry deadline", () => {
+  testPromise("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli.runEntry(hangingEntry(~timeout=Some(50)))
+    expect(r.status)->toEqual(RunnerTypes.Fail)
+    switch r.mismatch {
+    | Some(Outcome.Throw({error})) => expect(error->String.includes("timed out"))->toEqual(true)
+    | _ => JsError.throwWithMessage("expected a timeout Throw mismatch")
+    }
+  })
+
+  testPromise("a body that resolves within the deadline passes", async () => {
+    let entry: Collector.entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: [],
+      slice: None,
+      body: () => Promise.resolve(Outcome.pass),
+      status: Collector.Runnable,
+      location: None,
+      timeout: Some(1000),
+    }
+    let r = await Cli.runEntry(entry)
+    expect(r.status)->toEqual(RunnerTypes.Pass)
+  })
+})
+
+describe("Collector.activate", () => {
+  testSync("resets a leaked skipDepth to zero", () => {
+    // Simulate the leak a throwing xdescribe body would leave behind.
+    Collector.skipDepth := 3
+    Collector.activate()
+    expect(Collector.skipDepth.contents)->toEqual(0)
+    Collector.deactivate()
+  })
+})

package/tests/CliRunEntryTest.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Cli$ReventlessGwt from "../src/Cli.res.mjs";
+import * as Outcome$ReventlessGwt from "../src/Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "../src/Collector.res.mjs";
+
+function hangingEntry(timeout) {
+  return {
+    id: "hangs",
+    name: "hangs forever",
+    describePath: [],
+    slice: undefined,
+    body: () => new Promise((_resolve, _reject) => {}),
+    status: "Runnable",
+    location: undefined,
+    timeout: timeout
+  };
+}
+
+globalThis.describe("Cli.runEntry deadline", () => {
+  globalThis.test("a hung body is reported as a timeout, not a wedge", async () => {
+    let r = await Cli$ReventlessGwt.runEntry(hangingEntry(50));
+    globalThis.expect(r.status).toEqual("Fail");
+    let match = r.mismatch;
+    if (match === undefined) {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    if (match.TAG !== "Throw") {
+      return Stdlib_JsError.throwWithMessage("expected a timeout Throw mismatch");
+    }
+    globalThis.expect(match.error.includes("timed out")).toEqual(true);
+  });
+  globalThis.test("a body that resolves within the deadline passes", async () => {
+    let entry_describePath = [];
+    let entry_body = () => Promise.resolve(Outcome$ReventlessGwt.pass);
+    let entry_timeout = 1000;
+    let entry = {
+      id: "ok",
+      name: "resolves fast",
+      describePath: entry_describePath,
+      slice: undefined,
+      body: entry_body,
+      status: "Runnable",
+      location: undefined,
+      timeout: entry_timeout
+    };
+    let r = await Cli$ReventlessGwt.runEntry(entry);
+    globalThis.expect(r.status).toEqual("Pass");
+  });
+});
+
+globalThis.describe("Collector.activate", () => {
+  globalThis.test("resets a leaked skipDepth to zero", () => {
+    Collector$ReventlessGwt.skipDepth.contents = 3;
+    Collector$ReventlessGwt.activate();
+    globalThis.expect(Collector$ReventlessGwt.skipDepth.contents).toEqual(0);
+    Collector$ReventlessGwt.deactivate();
+  });
+});
+
+export {
+  hangingEntry,
+}
+/*  Not a pure module */

package/tests/CliWatchScopeTest.res

@@ -0,0 +1,62 @@
+// Unit tests for the watch re-run scope algebra (B1): a plain edit narrows the
+// re-run to its owning test package, structural/add/full triggers widen to
+// RunAll, and scopes coalesce (RunAll absorbing) while a pass is in flight.
+
+open JestGlobals
+
+describe("Cli.mergeScope", () => {
+  testSync("RunAll absorbs on the left", () =>
+    expect(Cli.mergeScope(RunAll, RunPackages(["/p/a"])))->toEqual(Cli.RunAll)
+  )
+  testSync("RunAll absorbs on the right", () =>
+    expect(Cli.mergeScope(RunPackages(["/p/a"]), RunAll))->toEqual(Cli.RunAll)
+  )
+  testSync("two RunPackages union their dirs, deduplicated", () =>
+    expect(Cli.mergeScope(RunPackages(["/p/a", "/p/b"]), RunPackages(["/p/b", "/p/c"])))->toEqual(
+      Cli.RunPackages(["/p/a", "/p/b", "/p/c"]),
+    )
+  )
+  testSync("RunAll merged with RunAll stays RunAll", () =>
+    expect(Cli.mergeScope(RunAll, RunAll))->toEqual(Cli.RunAll)
+  )
+})
+
+describe("Cli.pathUnderDir", () => {
+  testSync("a file inside the dir is under it", () =>
+    expect(Cli.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA"))->toEqual(true)
+  )
+  testSync("a sibling with a shared prefix is NOT under it", () =>
+    // /p/pkgABC must not be treated as inside /p/pkgA — the trailing separator
+    // guards against the bare-prefix false positive.
+    expect(Cli.pathUnderDir("/p/pkgABC/tests/FooGwt.res.mjs", "/p/pkgA"))->toEqual(false)
+  )
+  testSync("an unrelated path is not under it", () =>
+    expect(Cli.pathUnderDir("/p/pkgB/tests/BarGwt.res.mjs", "/p/pkgA"))->toEqual(false)
+  )
+  testSync("a trailing-slash dir still matches", () =>
+    expect(Cli.pathUnderDir("/p/pkgA/tests/FooGwt.res.mjs", "/p/pkgA/"))->toEqual(true)
+  )
+})
+
+describe("Cli.scopeSubset", () => {
+  let all = [
+    "/p/pkgA/tests/FooGwt.res.mjs",
+    "/p/pkgA/tests/BarGwt.res.mjs",
+    "/p/pkgB/tests/BazGwt.res.mjs",
+  ]
+  testSync("RunAll returns every path", () =>
+    expect(Cli.scopeSubset(RunAll, all))->toEqual(all)
+  )
+  testSync("RunPackages keeps only files under the given dirs", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgA"]), all))->toEqual([
+      "/p/pkgA/tests/FooGwt.res.mjs",
+      "/p/pkgA/tests/BarGwt.res.mjs",
+    ])
+  )
+  testSync("RunPackages over multiple dirs unions their files", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgA", "/p/pkgB"]), all))->toEqual(all)
+  )
+  testSync("RunPackages with no matching dir yields no files", () =>
+    expect(Cli.scopeSubset(RunPackages(["/p/pkgZ"]), all))->toEqual([])
+  )
+})