Merge pull request #94 from thefrontside/cl/test-adapter-before-all

✨Add global "onetime" setup to test adapter

Author: cowboyd

bdd/deno.json

@@ -1,7 +1,7 @@
 {
   "name": "@effectionx/bdd",
   "exports": "./mod.ts",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "imports": {
     "effection": "npm:effection@^3",

bdd/mod.ts

@@ -25,6 +25,10 @@ export function describe(name: string, body: () => void) {
 describe.skip = $describe.skip;
 describe.only = $describe.only;
 
+export function beforeAll(body: () => Operation<void>) {
+  current?.addOnetimeSetup(body);
+}
+
 export function beforeEach(body: () => Operation<void>) {
   current?.addSetup(body);
 }

test-adapter/README.md

@@ -25,9 +25,14 @@ describe("something", () => {
 
   adapter.addSetup(function*() {
     /* do some setup. equivalent of beforeEach() */
-	/* contexts set here will be visible in the test */*
+	/* contexts set here will be visible in the test */
   });
 
+  adapter.addOnetimeSetup(function*() {
+    /* do some setup that will only happen once. equivalent of beforeAll() */
+	/* contexts set here will be visible in the test */
+  });
+
   it("does a thing", async () => {
     await adapter.runTest(function*() {
 	  /* ... the body of the test */

test-adapter/deno.json

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

test-adapter/mod.ts

@@ -1,5 +1,5 @@
 import type { Future, Operation, Result, Scope } from "effection";
-import { createScope, Err, Ok } from "effection";
+import { Err, Ok, run, suspend, useScope, withResolvers } from "effection";
 
 export interface TestOperation {
   (): Operation<void>;
@@ -23,12 +23,6 @@ export interface TestAdapter {
    */
   readonly fullname: string;
 
-  /**
-   * Every test adapter has its own Effection `Scope` which holds the resources necessary
-   * to run this test.
-   */
-  readonly scope: Scope;
-
   /**
    * A list of this test adapter and every adapter that it descends from.
    */
@@ -38,14 +32,20 @@ export interface TestAdapter {
    * The setup operations that will be run by this test adapter. It only includes those
    * setups that are associated with this adapter, not those of its ancestors.
    */
-  readonly setups: TestOperation[];
+  readonly setup: { all: TestOperation[]; each: TestOperation[] };
 
   /**
    * Add a setup operation to every test that is part of this adapter. In BDD integrations,
    * this is usually called by `beforEach()`
    */
   addSetup(op: TestOperation): void;
 
+  /**
+   * Add a setup operation that will run exactly once before any tests that are run in this
+   * adapter. In BDD integrations, this is usually called by beforeAll()
+   */
+  addOnetimeSetup(op: TestOperation): void;
+
   /**
    * Actually run a test. This evaluates all setup operations, and then after those have completed
    * it runs the body of the test itself.
@@ -57,6 +57,13 @@ export interface TestAdapter {
    * This basically destroys the Effection `Scope` associated with this adapter.
    */
   destroy(): Future<void>;
+
+  /**
+   * Used internally to prepare adapters to run test
+   *
+   * @ignore
+   */
+  ["@@init@@"](): Operation<Scope>;
 }
 
 export interface TestAdapterOptions {
@@ -87,16 +94,18 @@ const anonymousNames: Iterator<string, never> = (function* () {
 export function createTestAdapter(
   options: TestAdapterOptions = {},
 ): TestAdapter {
-  const setups: TestOperation[] = [];
+  const setup = {
+    all: [] as TestOperation[],
+    each: [] as TestOperation[],
+  };
   const { parent, name = anonymousNames.next().value } = options;
 
-  const [scope, destroy] = createScope(parent?.scope);
+  let scope: Scope | undefined = undefined;
 
   const adapter: TestAdapter = {
     parent,
     name,
-    scope,
-    setups,
+    setup,
     get lineage() {
       const lineage = [adapter];
       for (let current = parent; current; current = current.parent) {
@@ -108,27 +117,69 @@ export function createTestAdapter(
       return adapter.lineage.map((adapter) => adapter.name).join(" > ");
     },
     addSetup(op) {
-      setups.push(op);
+      setup.each.push(op);
+    },
+    addOnetimeSetup(op) {
+      setup.all.push(op);
     },
     runTest(op) {
-      return scope.run(function* () {
-        const allSetups = adapter.lineage.reduce(
-          (all, adapter) => all.concat(adapter.setups),
-          [] as TestOperation[],
-        );
-        try {
-          for (const setup of allSetups) {
-            yield* setup();
-          }
+      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();
+            }
+            yield* op();
+          });
+
+          yield* test;
+        }())
+      );
+    },
+
+    // no-op that will be replaced once initialze
+    destroy: () => run(function* () {}),
+
+    *["@@init@@"]() {
+      if (scope) {
+        return scope;
+      }
+
+      let parentScope = parent
+        ? yield* parent["@@init@@"]()
+        : yield* useScope();
+
+      let initialized = withResolvers<Scope>();
+
+      let task = yield* parentScope.spawn(function* () {
+        scope = yield* useScope();
+        for (let op of setup.all) {
           yield* op();
-          return Ok<void>(void 0);
-        } catch (error) {
-          return Err(error as Error);
         }
+        initialized.resolve(scope);
+        yield* suspend();
       });
+
+      adapter.destroy = () => run(task.halt);
+
+      return yield* initialized.operation;
     },
-    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

@@ -1,7 +1,7 @@
 import { describe, it } from "@std/testing/bdd";
 import { expect } from "@std/expect";
+import { createContext, resource } from "effection";
 import { createTestAdapter } from "../mod.ts";
-import { createContext } from "effection";
 
 describe("TestAdapter", () => {
   it("can run a test", async () => {
@@ -32,4 +32,64 @@ describe("TestAdapter", () => {
       expect(yield* count.expect()).toEqual(8);
     });
   });
+
+  it("has one time setup", async () => {
+    let grandparent = createTestAdapter({ name: "grandparent" });
+
+    let context = createContext<string>("context", "uninitialized");
+
+    let sequence: string[] = [];
+    let contexts: Record<string, string> = {};
+
+    grandparent.addOnetimeSetup(function* () {
+      yield* context.set("initialized");
+
+      yield* resource<void>(function* (provide) {
+        try {
+          sequence.push("grandparent/setup:once");
+          yield* provide();
+        } finally {
+          sequence.push("grandparent/teardown:once");
+        }
+      });
+    });
+
+    grandparent.addSetup(function* () {
+      sequence.push("grandparent/setup:each");
+    });
+
+    let parent = createTestAdapter({ name: "parent", parent: grandparent });
+
+    parent.addOnetimeSetup(() =>
+      resource<void>(function* (provide) {
+        try {
+          sequence.push("parent/setup:once");
+          contexts["parent"] = yield* context.expect();
+          yield* provide();
+        } finally {
+          sequence.push("parent/teardown:once");
+        }
+      })
+    );
+
+    let child = createTestAdapter({ name: "child", parent });
+
+    await child.runTest(function* () {
+      sequence.push("child/run");
+      contexts["child"] = yield* context.expect();
+    });
+
+    await grandparent.destroy();
+
+    expect(sequence).toEqual([
+      "grandparent/setup:once",
+      "parent/setup:once",
+      "grandparent/setup:each",
+      "child/run",
+      "parent/teardown:once",
+      "grandparent/teardown:once",
+    ]);
+
+    expect(contexts).toEqual({ parent: "initialized", child: "initialized" });
+  });
 });