Merge pull request #96 from thefrontside/multi-test-adapter

🐛 run more than one test

Author: cowboyd

test-adapter/box.ts

@@ -0,0 +1,16 @@
+import { Err, Ok, type Operation, type Result } from "effection";
+
+export function* box<T>(content: () => Operation<T>): Operation<Result<T>> {
+  try {
+    return Ok(yield* content());
+  } catch (error) {
+    return Err(error as Error);
+  }
+}
+
+export function unbox<T>(result: Result<T>): T {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}

test-adapter/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectionx/test-adapter",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

test-adapter/mod.ts

@@ -1,5 +1,19 @@
-import type { Future, Operation, Result, Scope } from "effection";
-import { Err, Ok, run, suspend, useScope, withResolvers } from "effection";
+import type {
+  Future,
+  Operation,
+  Result,
+  Scope,
+  WithResolvers,
+} from "effection";
+import {
+  createScope,
+  Ok,
+  run,
+  suspend,
+  useScope,
+  withResolvers,
+} from "effection";
+import { box } from "./box.ts";
 
 export interface TestOperation {
   (): Operation<void>;
@@ -63,7 +77,7 @@ export interface TestAdapter {
    *
    * @ignore
    */
-  ["@@init@@"](): Operation<Scope>;
+  ["@@init@@"](): Operation<Result<Scope>>;
 }
 
 export interface TestAdapterOptions {
@@ -100,7 +114,8 @@ export function createTestAdapter(
   };
   const { parent, name = anonymousNames.next().value } = options;
 
-  let scope: Scope | undefined = undefined;
+  let scope: WithResolvers<Result<Scope>> | undefined = undefined;
+  let destroy: () => Operation<void> = function* () {};
 
   const adapter: TestAdapter = {
     parent,
@@ -123,63 +138,65 @@ export function createTestAdapter(
       setup.all.push(op);
     },
     runTest(op) {
-      return run(() =>
-        box(function* () {
-          const setups = adapter.lineage.reduce(
-            (all, adapter) => all.concat(adapter.setup.each),
-            [] as TestOperation[],
-          );
-
-          let scope = yield* adapter["@@init@@"]();
-
-          let test = yield* scope.spawn(function* () {
-            for (const setup of setups) {
-              yield* setup();
+      return run(function* () {
+        let init = yield* adapter["@@init@@"]();
+        if (!init.ok) {
+          return init;
+        }
+        let scope = init.value;
+
+        const setups = adapter.lineage.reduce(
+          (all, adapter) => all.concat(adapter.setup.each),
+          [] as TestOperation[],
+        );
+
+        let test = yield* scope.spawn(() =>
+          box(function* () {
+            for (let fn of setups) {
+              yield* fn();
             }
             yield* op();
-          });
-
-          yield* test;
-        }())
-      );
+          })
+        );
+        return yield* test;
+      });
     },
 
-    // no-op that will be replaced once initialze
-    destroy: () => run(function* () {}),
-
     *["@@init@@"]() {
       if (scope) {
-        return scope;
+        return yield* scope.operation;
       }
+      scope = withResolvers<Result<Scope>>();
 
-      let parentScope = parent
-        ? yield* parent["@@init@@"]()
-        : yield* useScope();
+      let parent = adapter.parent
+        ? yield* adapter.parent["@@init@@"]()
+        : Ok(createScope()[0]);
 
-      let initialized = withResolvers<Scope>();
+      if (!parent.ok) {
+        scope.resolve(parent);
+        return yield* scope.operation;
+      }
 
-      let task = yield* parentScope.spawn(function* () {
-        scope = yield* useScope();
-        for (let op of setup.all) {
-          yield* op();
+      let task = yield* parent.value.spawn(function* () {
+        let init = yield* box(function* () {
+          for (let initializer of adapter.setup.all) {
+            yield* initializer();
+          }
+        });
+        if (!init.ok) {
+          scope!.resolve(init);
+        } else {
+          scope!.resolve(Ok(yield* useScope()));
+          yield* suspend();
         }
-        initialized.resolve(scope);
-        yield* suspend();
       });
 
-      adapter.destroy = () => run(task.halt);
+      destroy = task.halt;
 
-      return yield* initialized.operation;
+      return yield* scope.operation;
     },
+    destroy: () => run(destroy),
   };
 
   return adapter;
 }
-
-function* box<T>(op: Operation<T>): Operation<Result<T>> {
-  try {
-    return Ok(yield* op);
-  } catch (error) {
-    return Err(error as Error);
-  }
-}

test-adapter/test/adapter.test.ts

@@ -55,7 +55,14 @@ describe("TestAdapter", () => {
     });
 
     grandparent.addSetup(function* () {
-      sequence.push("grandparent/setup:each");
+      yield* resource<void>(function* (provide) {
+        try {
+          sequence.push("grandparent/setup:each");
+          yield* provide();
+        } finally {
+          sequence.push("grandparent/teardown:each");
+        }
+      });
     });
 
     let parent = createTestAdapter({ name: "parent", parent: grandparent });
@@ -72,24 +79,65 @@ describe("TestAdapter", () => {
       })
     );
 
-    let child = createTestAdapter({ name: "child", parent });
+    parent.addSetup(() =>
+      resource(function* (provide) {
+        try {
+          sequence.push("parent/setup:each");
+          yield* provide();
+        } finally {
+          sequence.push("parent/teardown:each");
+        }
+      })
+    );
 
-    await child.runTest(function* () {
-      sequence.push("child/run");
-      contexts["child"] = yield* context.expect();
+    let first = createTestAdapter({ name: "child", parent });
+
+    let result = await first.runTest(function* () {
+      sequence.push("first-child/run");
+      contexts["first-child/run"] = yield* context.expect();
+    });
+
+    if (!result.ok) {
+      throw result.error;
+    }
+
+    let second = createTestAdapter({ name: "child", parent });
+
+    result = await second.runTest(function* () {
+      sequence.push("second-child/run");
+      contexts["second-child/run"] = yield* context.expect();
     });
 
+    if (!result.ok) {
+      throw result.error;
+    }
+
     await grandparent.destroy();
 
     expect(sequence).toEqual([
       "grandparent/setup:once",
       "parent/setup:once",
       "grandparent/setup:each",
-      "child/run",
+      "parent/setup:each",
+      "first-child/run",
+      "parent/teardown:each",
+      "grandparent/teardown:each",
+      "grandparent/setup:each",
+      "parent/setup:each",
+      "second-child/run",
+      "parent/teardown:each",
+      "grandparent/teardown:each",
       "parent/teardown:once",
       "grandparent/teardown:once",
     ]);
 
-    expect(contexts).toEqual({ parent: "initialized", child: "initialized" });
+    expect(contexts).toEqual({
+      parent: "initialized",
+      "first-child/run": "initialized",
+      "second-child/run": "initialized",
+    });
+  });
+
+  it("can run multiple tests", async () => {
   });
 });