@autometa/jest-executor 0.5.10 → 0.6.1

package/.turbo/turbo-test.log

@@ -1,15 +1,15 @@
 
-> @autometa/jest-executor@0.5.1 test /Users/ben.aherne/Documents/GitHub/autometa/packages/jest-executor
+> @autometa/jest-executor@0.5.10 test /Users/ben.aherne/Documents/GitHub/autometa/packages/jest-executor
 > vitest run --passWithNoTests
 
 
  RUN  v1.4.0 /Users/ben.aherne/Documents/GitHub/autometa/packages/jest-executor
 
- ✓ src/timeout-selector.spec.ts  (2 tests) 2ms
- ✓ src/executor.spec.ts  (15 tests) 9ms
+ ✓ src/timeout-selector.spec.ts  (2 tests) 4ms
+ ✓ src/executor.spec.ts  (15 tests) 6ms
 
  Test Files  2 passed (2)
       Tests  17 passed (17)
-   Start at  18:24:28
-   Duration  5.24s (transform 2.06s, setup 0ms, collect 4.93s, tests 11ms, environment 0ms, prepare 1.98s)
+   Start at  13:56:48
+   Duration  6.00s (transform 2.24s, setup 0ms, collect 7.66s, tests 10ms, environment 0ms, prepare 2.38s)
 

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @autometa/jest-executor
 
+## 0.6.1
+
+### Patch Changes
+
+- da669a3: feat: disposable injectables
+- Updated dependencies [da669a3]
+  - @autometa/injection@0.1.4
+  - @autometa/app@0.4.1
+  - @autometa/config@0.1.26
+  - @autometa/scopes@0.7.1
+  - @autometa/test-builder@0.4.1
+  - @autometa/gherkin@0.7.1
+  - @autometa/events@0.3.1
+
+## 0.6.0
+
+### Minor Changes
+
+- 7440e9f: feat: new group based hooks for feature, rule, outline and examples
+
+### Patch Changes
+
+- Updated dependencies [7440e9f]
+  - @autometa/test-builder@0.4.0
+  - @autometa/gherkin@0.7.0
+  - @autometa/events@0.3.0
+  - @autometa/scopes@0.7.0
+  - @autometa/app@0.4.0
+  - @autometa/config@0.1.25
+
 ## 0.5.10
 
 ### Patch Changes

package/dist/esm/index.js

@@ -52,6 +52,10 @@ function chooseTimeout(timeout1, timeout2) {
 // src/executor.ts
 import { NullTimeout as NullTimeout2, Timeout as Timeout2 } from "@autometa/scopes";
 import { Container, defineContainerContext } from "@autometa/injection";
+var outlineApps = /* @__PURE__ */ new Map();
+var examplesApps = /* @__PURE__ */ new Map();
+var featureApps = /* @__PURE__ */ new Map();
+var ruleApps = /* @__PURE__ */ new Map();
 function execute({ app, world }, global, bridge, events, config) {
   const globalBridge = new GlobalBridge(global);
   const featureTitle = bridge.data.scope.title(bridge.data.gherkin);
@@ -97,6 +101,46 @@ function execute({ app, world }, global, bridge, events, config) {
       localApp = testContainer.get(app);
       localApp.world = testContainer.get(world);
       localApp.di = testContainer;
+      if (!featureApps.has(name)) {
+        featureApps.set(name, []);
+      }
+      featureApps.get(name)?.push(localApp);
+    });
+    bridge.data.scope.hooks.beforeFeatureHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        chosenTimeout,
+        hook.options.timeout
+      ).getTimeout(config).milliseconds;
+      beforeAll(async () => {
+        if (!hook.canExecute(...bridge.data.gherkin.tags)) {
+          return;
+        }
+        const tags2 = bridge?.data?.gherkin?.tags ?? [];
+        const report = await hook.execute(staticApp, ...tags2);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          throw new AutomationError(message, { cause: report.error });
+        }
+      }, hookTimeout);
+    });
+    bridge.data.scope.hooks.afterFeatureHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        chosenTimeout,
+        hook.options.timeout
+      ).getTimeout(config).milliseconds;
+      afterAll(async () => {
+        if (!hook.canExecute(...bridge.data.gherkin.tags)) {
+          return;
+        }
+        const testName = expect.getState().currentTestName;
+        const tags2 = bridge?.data?.gherkin?.tags ?? [];
+        const apps = featureApps.get(testName);
+        const report = await hook.execute(staticApp, apps, ...tags2);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          throw new AutomationError(message, { cause: report.error });
+        }
+      }, hookTimeout);
     });
     bootstrapSetupHooks(globalBridge, staticApp, events, [
       config,
@@ -136,6 +180,12 @@ function execute({ app, world }, global, bridge, events, config) {
       chosenTimeout
     ]);
     bootstrapTeardownHooks(bridge, staticApp, events, [config, chosenTimeout]);
+    afterEach(async () => {
+      await testContainer.disposeAll();
+    });
+    afterAll(async () => {
+      await globalContainer.disposeGlobal();
+    });
   });
   afterAll(async () => {
     const failures = Query.find.failed(bridge);
@@ -153,6 +203,10 @@ function execute({ app, world }, global, bridge, events, config) {
       const message = `${count} asynchronous Test Events were rejected.`;
       console.warn(message);
     }
+    featureApps.clear();
+    outlineApps.clear();
+    examplesApps.clear();
+    ruleApps.clear();
   });
 }
 function bootstrapBackground(root, bridge, localApp, events, [config, timeout]) {
@@ -329,6 +383,7 @@ function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [co
   } = bridge;
   const title = scope.title(gherkin);
   const retry = [...gherkin.tags].find((tag) => tag.startsWith("@retries="));
+  const { beforeScenarioOutlineHooks, afterScenarioOutlineHooks } = scope.hooks;
   const [group, modifier] = getGroupOrModifier(
     bridge,
     config.current.test?.tagFilter
@@ -337,7 +392,58 @@ function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [co
     timeout,
     bridge.data.scope.timeout
   ).getTimeout(config).milliseconds;
+  const original = localApp;
+  localApp = () => {
+    const testName = expect.getState().currentTestName;
+    if (!outlineApps.has(testName)) {
+      outlineApps.set(testName, []);
+    }
+    const apps = outlineApps.get(testName);
+    const app = original();
+    apps.push(app);
+    return app;
+  };
   group(title, () => {
+    beforeScenarioOutlineHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        timeout,
+        hook.options.timeout
+      ).getTimeout(config).milliseconds;
+      beforeAll(async () => {
+        if (!hook.canExecute(...gherkin.tags)) {
+          return;
+        }
+        events.beforeScenarioOutline.emitStart({
+          title,
+          modifier,
+          tags: [...gherkin.tags]
+        });
+        const tags = gherkin.tags ?? [];
+        events.beforeScenarioOutline.emitStart({
+          title,
+          modifier,
+          tags: [...gherkin.tags]
+        });
+        const report = await hook.execute(staticApp, ...tags);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          events.beforeScenarioOutline.emitEnd({
+            title,
+            modifier,
+            error: report.error,
+            tags: [...gherkin.tags],
+            status: "FAILED"
+          });
+          throw new AutomationError(message, { cause: report.error });
+        }
+        events.beforeScenarioOutline.emitEnd({
+          title,
+          modifier,
+          tags: [...gherkin.tags],
+          status: "PASSED"
+        });
+      }, hookTimeout);
+    });
     beforeAll(() => {
       if (retry) {
         const count = parseInt(retry.split("=")[1]);
@@ -359,6 +465,43 @@ function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [co
     });
     bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout]);
     bootstrapTeardownHooks(bridge, staticApp, events, [config, timeout]);
+    afterScenarioOutlineHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        timeout,
+        hook.options.timeout
+      ).getTimeout(config).milliseconds;
+      afterAll(async () => {
+        if (!hook.canExecute(...gherkin.tags)) {
+          return;
+        }
+        const testName = expect.getState().currentTestName;
+        const tags = gherkin.tags ?? [];
+        const apps = outlineApps.get(testName);
+        events.afterScenarioOutline.emitStart({
+          title,
+          modifier,
+          tags: [...gherkin.tags]
+        });
+        const report = await hook.execute(staticApp, apps, ...tags);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          events.scenarioOutline.emitEnd({
+            title,
+            modifier,
+            error: report.error,
+            tags: [...gherkin.tags],
+            status: "FAILED"
+          });
+          throw new AutomationError(message, { cause: report.error });
+        }
+        events.afterScenarioOutline.emitEnd({
+          title,
+          modifier,
+          tags: [...gherkin.tags],
+          status: "PASSED"
+        });
+      }, hookTimeout);
+    });
     afterAll(() => {
       const failures = Query.find.failed(bridge);
       const status = getStatus(modifier, failures);
@@ -368,6 +511,8 @@ function bootstrapScenarioOutline(root, bridge, localApp, staticApp, events, [co
         tags: [...gherkin.tags],
         status
       });
+      outlineApps.clear();
+      examplesApps.clear();
     }, chosenTimeout);
   });
 }
@@ -377,6 +522,17 @@ function bootstrapExamples(root, example, localApp, staticApp, events, timeout)
   const retry = [...example.data.gherkin.tags].find(
     (tag) => tag.startsWith("@retries=")
   );
+  const original = localApp;
+  localApp = () => {
+    const testName = expect.getState().currentTestName ?? "unnamed test";
+    if (!examplesApps.has(testName)) {
+      examplesApps.set(testName, []);
+    }
+    const apps = examplesApps.get(testName);
+    const app = original();
+    apps.push(app);
+    return app;
+  };
   const [group] = getGroupOrModifier(
     example,
     timeout[0].current.test?.tagFilter
@@ -388,7 +544,62 @@ function bootstrapExamples(root, example, localApp, staticApp, events, timeout)
         jest.retryTimes(count);
       }
     });
+    example.data.scope.hooks.beforeExamplesHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        timeout[1],
+        hook.options.timeout
+      ).getTimeout(timeout[0]).milliseconds;
+      beforeAll(async () => {
+        if (!hook.canExecute(...example.data.gherkin.tags)) {
+          return;
+        }
+        const tags = example?.data?.gherkin?.tags ?? [];
+        events.beforeExamples.emitStart({
+          title,
+          tags: [...tags]
+        });
+        const report = await hook.execute(staticApp, ...tags);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          events.beforeExamples.emitEnd({
+            title,
+            error: report.error,
+            tags: [...tags],
+            status: "FAILED"
+          });
+          throw new AutomationError(message, { cause: report.error });
+        }
+        events.beforeExamples.emitEnd({
+          title,
+          tags: [...tags],
+          status: "PASSED"
+        });
+      }, hookTimeout);
+    });
     bootstrapScenarios(root, example, localApp, staticApp, events, timeout);
+    example.data.scope.hooks.afterExamplesHooks.forEach((hook) => {
+      const hookTimeout = chooseTimeout(
+        timeout[1],
+        hook.options.timeout
+      ).getTimeout(timeout[0]).milliseconds;
+      afterAll(async () => {
+        const testName = expect.getState().currentTestName;
+        if (!hook.canExecute(...example.data.gherkin.tags)) {
+          return;
+        }
+        const tags = example?.data?.gherkin?.tags ?? [];
+        const apps = examplesApps.get(testName);
+        const report = await hook.execute(staticApp, apps, ...tags);
+        if (report.error) {
+          const message = `${hook.name}: ${hook.description} failed to execute.`;
+          throw new AutomationError(message, { cause: report.error });
+        }
+      }, hookTimeout);
+    });
+    afterAll(() => {
+      const testName = expect.getState().currentTestName;
+      examplesApps.delete(testName);
+    });
   });
 }
 function bootstrapRules(bridge, localApp, staticApp, events, [config, timeout]) {
@@ -421,6 +632,83 @@ function bootstrapRules(bridge, localApp, staticApp, events, [config, timeout])
           const count = parseInt(retry.split("=")[1]);
           jest.retryTimes(count);
         }
+        const original = localApp;
+        localApp = () => {
+          const testName = expect.getState().currentTestName;
+          if (!ruleApps.has(testName)) {
+            ruleApps.set(testName, []);
+          }
+          const apps = ruleApps.get(testName);
+          const app = original();
+          apps.push(app);
+          return app;
+        };
+      });
+      bridge.data.scope.hooks.beforeRuleHooks.forEach((hook) => {
+        const hookTimeout = chooseTimeout(
+          ruleTimeout,
+          hook.options.timeout
+        ).getTimeout(config).milliseconds;
+        beforeAll(async () => {
+          if (!hook.canExecute(...data.gherkin.tags)) {
+            return;
+          }
+          const tags2 = data.gherkin.tags ?? [];
+          events.beforeRule.emitStart({
+            title: `${hook.name}: ${hook.description}`,
+            tags: [...tags2]
+          });
+          const report = await hook.execute(staticApp, ...tags2);
+          if (report.error) {
+            const message = `${hook.name}: ${hook.description} failed to execute.`;
+            events.beforeRule.emitEnd({
+              title: `${hook.name}: ${hook.description}`,
+              tags: [...tags2],
+              status: "FAILED",
+              error: report.error
+            });
+            throw new AutomationError(message, { cause: report.error });
+          }
+          events.beforeRule.emitEnd({
+            title: `${hook.name}: ${hook.description}`,
+            tags: [...tags2],
+            status: "PASSED"
+          });
+        }, hookTimeout);
+      });
+      bridge.data.scope.hooks.afterRuleHooks.forEach((hook) => {
+        const hookTimeout = chooseTimeout(
+          ruleTimeout,
+          hook.options.timeout
+        ).getTimeout(config).milliseconds;
+        afterAll(async () => {
+          const testName = expect.getState().currentTestName;
+          if (!hook.canExecute(...data.gherkin.tags)) {
+            return;
+          }
+          const tags2 = data.gherkin.tags ?? [];
+          const apps = ruleApps.get(testName);
+          events.afterRule.emitStart({
+            title: `${hook.name}: ${hook.description}`,
+            tags: [...tags2]
+          });
+          const report = await hook.execute(staticApp, apps, ...tags2);
+          if (report.error) {
+            const message = `${hook.name}: ${hook.description} failed to execute.`;
+            events.afterRule.emitEnd({
+              title: `${hook.name}: ${hook.description}`,
+              tags: [...tags2],
+              status: "FAILED",
+              error: report.error
+            });
+            throw new AutomationError(message, { cause: report.error });
+          }
+          events.afterRule.emitEnd({
+            title: `${hook.name}: ${hook.description}`,
+            tags: [...tags2],
+            status: "PASSED"
+          });
+        }, hookTimeout);
       });
       bootstrapSetupHooks(rule, staticApp, events, transferTimeout);
       bootstrapBeforeHooks(bridge, rule, localApp, events, transferTimeout);
@@ -444,6 +732,8 @@ function bootstrapRules(bridge, localApp, staticApp, events, [config, timeout])
           tags: [...data.gherkin.tags],
           status
         });
+        const testName = expect.getState().currentTestName;
+        ruleApps.delete(testName);
       }, ruleTimeout.milliseconds);
     });
   });
@@ -496,9 +786,10 @@ function bootstrapBeforeHooks(root, bridge, localApp, events, [config, timeout])
     bridge.data.scope.timeout
   ).getTimeout(config);
   bridge.data.scope.hooks.before.forEach((hook) => {
-    const hookTimeout = chooseTimeout(chosenTimeout, hook.timeout).getTimeout(
-      config
-    ).milliseconds;
+    const hookTimeout = chooseTimeout(
+      chosenTimeout,
+      hook.options.timeout
+    ).getTimeout(config).milliseconds;
     beforeEach(async () => {
       const testName = expect.getState().currentTestName;
       if (!testName)
@@ -541,7 +832,7 @@ function bootstrapSetupHooks(bridge, staticApp, events, [config, timeout]) {
   setups.forEach((hook) => {
     const hookTimeout = chooseTimeout(
       Timeout2.from(chosenTimeout),
-      hook.timeout
+      hook.options.timeout
     ).getTimeout(config).milliseconds;
     const tags = gherkin.tags ?? [];
     beforeAll(async () => {
@@ -572,7 +863,7 @@ function bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout])
   scope.hooks.after.forEach((hook) => {
     const hookTimeout = chooseTimeout(
       Timeout2.from(chosenTimeout),
-      hook.timeout
+      hook.options.timeout
     ).getTimeout(config).milliseconds;
     afterEach(async () => {
       const testName = expect.getState().currentTestName;
@@ -607,15 +898,16 @@ function bootstrapAfterHooks(root, bridge, localApp, events, [config, timeout])
   });
 }
 function bootstrapTeardownHooks(bridge, staticApp, event, [config, timeout]) {
-  const tags = bridge.data.gherkin.tags ?? [];
+  const tags = [...bridge.data.gherkin.tags];
   const { scope } = bridge.data;
   const chosenTimeout = chooseTimeout(timeout, scope.timeout).getTimeout(
     config
   );
   scope.hooks.teardown.forEach((hook) => {
-    const hookTimeout = chooseTimeout(chosenTimeout, hook.timeout).getTimeout(
-      config
-    ).milliseconds;
+    const hookTimeout = chooseTimeout(
+      chosenTimeout,
+      hook.options.timeout
+    ).getTimeout(config).milliseconds;
     afterAll(async () => {
       if (!hook.canExecute(...tags)) {
         return;
@@ -624,7 +916,7 @@ function bootstrapTeardownHooks(bridge, staticApp, event, [config, timeout]) {
         title: `${hook.name}: ${hook.description}`,
         tags: [...tags]
       });
-      const report = await hook.execute(staticApp, ...tags);
+      const report = await hook.execute(staticApp, tags);
       event.teardown.emitEnd({
         title: `${hook.name}: ${hook.description}`,
         tags: [...tags],