Effection v4

.github/workflows/run-on-pr.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: volta-cli/action@v4
       - run: npm ci --ignore-scripts
       - run: npm run build
-      - run: npm run pkg -w action
+      - run: npm run build:action
       - name: covector status
         uses: ./packages/action
         id: covector

.github/workflows/test.yml

@@ -21,4 +21,5 @@ jobs:
       - uses: volta-cli/action@v4
       - run: npm ci
       - run: npm run build # covector CLI tests run built files
+      - run: npm run build:action
       - run: npm test

helpers/test-adapter.ts

@@ -0,0 +1,72 @@
+import type { Future, Operation, Scope } from "effection";
+import { createScope } from "effection";
+
+export interface TestOp {
+  (): Operation<void>;
+}
+
+export interface TestAdapter {
+  readonly parent?: TestAdapter;
+  readonly name: string;
+  readonly fullname: string;
+  readonly scope: Scope;
+  readonly lineage: Array<TestAdapter>;
+  readonly setups: TestOp[];
+  addSetup(op: TestOp): void;
+  runTest(body: TestOp): Future<void>;
+  destroy(): Future<void>;
+}
+
+export interface TestAdapterOptions {
+  name?: string;
+  parent?: TestAdapter;
+}
+
+const anonymousNames: Iterator<string, never> = (function* () {
+  let count = 1;
+  while (true) {
+    yield `anonymous test adapter ${count++}`;
+  }
+})();
+
+export function createTestAdapter(options: TestAdapterOptions): TestAdapter {
+  let setups: TestOp[] = [];
+  let { parent, name = anonymousNames.next().value } = options;
+
+  let [scope, destroy] = createScope(parent?.scope);
+
+  let adapter: TestAdapter = {
+    parent,
+    name,
+    scope,
+    setups,
+    get lineage() {
+      let lineage = [adapter];
+      for (let current = parent; current; current = current.parent) {
+        lineage.unshift(current);
+      }
+      return lineage;
+    },
+    get fullname() {
+      return adapter.lineage.map((adapter) => adapter.name).join(" > ");
+    },
+    addSetup(op) {
+      setups.push(op);
+    },
+    runTest(op) {
+      return scope.run(function* () {
+        let allSetups = adapter.lineage.reduce(
+          (all, adapter) => all.concat(adapter.setups),
+          [] as TestOp[]
+        );
+        for (let setup of allSetups) {
+          yield* setup();
+        }
+        yield* op();
+      });
+    },
+    destroy,
+  };
+
+  return adapter;
+}

helpers/test-scope.ts

@@ -1,55 +1,59 @@
-import { type Operation, run } from "effection";
-
-export interface TestScope {
-  addSetup(op: () => Operation<void>): void;
-  runTest(op: () => Operation<void>): Promise<void>;
-}
-
-export function createTestScope(): TestScope {
-  let setup: (() => Operation<void>)[] = [];
-  return {
-    addSetup(op) {
-      setup.push(op);
-    },
-    runTest(op) {
-      return run(function* () {
-        for (let step of setup) {
-          yield step();
-        }
-        yield op();
-      });
-    },
-  };
-}
+import { type Operation } from "effection";
+import { createTestAdapter, TestAdapter } from "./test-adapter";
 
 import * as vitest from "vitest";
 
-let scope: TestScope | undefined;
-
 function describeWithScope(
   name: string | Function,
-  factory?: vitest.SuiteFactory<{}>
-): vitest.SuiteCollector<{}> {
-  return vitest.describe(name, () => {
-    vitest.beforeEach(() => {
-      if (!scope) {
-        scope = createTestScope();
-      }
+  factory?: vitest.SuiteFactory
+): vitest.SuiteCollector {
+  return vitest.describe(name, (...args) => {
+    vitest.beforeAll((suite: any) => {
+      let parent = suite.suite?.adapter;
+      suite.adapter = createTestAdapter({ name: String(name), parent });
+    });
+
+    vitest.afterAll(async (suite: any) => {
+      await suite.adapter.destroy();
     });
+
     if (factory && typeof factory === "function") {
-      (<Function>factory)();
+      factory(...args);
     }
   });
 }
 
-describeWithScope.only = vitest.describe.only;
+describeWithScope.only = function describeWithScope(
+  name: string | Function,
+  factory?: vitest.SuiteFactory
+): vitest.SuiteCollector {
+  return vitest.describe.only(name, (...args) => {
+    vitest.beforeAll((suite: any) => {
+      let parent = suite.suite?.adapter;
+      suite.adapter = createTestAdapter({ name: String(name), parent });
+    });
+
+    vitest.afterAll(async (suite: any) => {
+      await suite.adapter.destroy();
+    });
+
+    if (factory && typeof factory === "function") {
+      factory(...args);
+    }
+  });
+};
 describeWithScope.skip = vitest.describe.skip;
-describeWithScope.skipIf = vitest.describe.skipIf;
+describeWithScope.skipIf = (condition: any) =>
+  condition ? describeWithScope.skip : describeWithScope;
+describeWithScope.runIf = (condition: any) =>
+  condition ? describeWithScope : describeWithScope.skip;
 
 export const describe = <typeof vitest.describe>(<unknown>describeWithScope);
 
 export function beforeEach(op: () => Operation<void>): void {
-  vitest.beforeEach(() => scope!.addSetup(op));
+  vitest.beforeEach((context: any) => {
+    context.task.suite.adapter.addSetup(op);
+  });
 }
 
 export function it(
@@ -58,9 +62,18 @@ export function it(
   timeout?: number
 ): void {
   if (op) {
-    return vitest.it(desc, async () => scope?.runTest(op), timeout);
+    return vitest.it(
+      desc,
+      async (context) => {
+        if (!context.task.suite?.adapter)
+          throw new Error("missing test adapter");
+        let adapter: TestAdapter = context.task.suite.adapter;
+        return adapter.runTest(op);
+      },
+      timeout
+    );
   } else {
-    return vitest.it.skip(desc, () => {});
+    return vitest.it.todo(desc);
   }
 }
 
@@ -70,19 +83,34 @@ it.only = function only(
   timeout?: number
 ): void {
   if (op) {
-    return vitest.it.only(desc, async () => scope!.runTest(op), timeout);
+    return vitest.it.only(
+      desc,
+      async (context) => {
+        if (!context.task.suite?.adapter)
+          throw new Error("missing test adapter");
+        let adapter: TestAdapter = context.task.suite.adapter;
+        return adapter.runTest(op);
+      },
+      timeout
+    );
   } else {
     return vitest.it.skip(desc, () => {});
   }
 };
 
-export function captureError<T>(op: Operation<T>): Operation<T | Error> {
-  return function* () {
-    try {
-      yield op;
-    } catch (error) {
-      return error;
-    }
+it.skip = function skip(
+  desc: string,
+  op?: () => Operation<void>,
+  timeout?: number
+): void {
+  return vitest.it.skip(desc, () => {});
+};
+
+export function* captureError<T>(op: Operation<T>): Operation<Error> {
+  try {
+    yield* op;
     throw new Error("expected operation to throw an error, but it did not!");
-  };
+  } catch (error) {
+    return error;
+  }
 }