Adding BeforeAll and AfterAll hooks

features/issues/758.feature

@@ -1,25 +1,30 @@
 # https://github.com/badeball/cypress-cucumber-preprocessor/issues/758
 
-Feature: visualizing hook with filter
- Scenario: visualizing hook with filter
+Feature: beforeAll and afterAll hooks
+ @fav
+ Scenario: beforeAll and afterAll hooks
  Given a file named "cypress/e2e/a.feature" with:
  """
- @foo
  Feature: a feature x
- Scenario: a scenario a
+ Scenario: a scenario b
  Given a step
 
- Feature: a feature x
- Scenario: a scenario b
- Given a step
+  @foo
+  Scenario: a scenario c
+  Given a step
  """
  And a file named "cypress/support/step_definitions/steps.js" with:
  """
  const { BeforeAll, AfterAll, Given } = require("@badeball/cypress-cucumber-preprocessor");
- BeforeAll(() => {})
+ let counter = 0
+ BeforeAll(() => {
+ expect(counter++, "Expect counter to be 0").to.equal(0)
+ })
  Given("a step", function() {
  })
- AfterAll(() => {})
+ AfterAll(() => {
+ expect(counter++, "Expect counter to be 1").to.equal(1)
+ })
  """
  When I run cypress
  Then it passes

lib/browser-runtime.ts

@@ -18,7 +18,7 @@ import DataTable from "./data_table";
 
 import {
  assignRegistry,
- freeRegistry,
+ freeRegistry, getRegistry,
  IHook,
  MissingDefinitionError,
  Registry,
@@ -268,12 +268,17 @@ function createFeature(context: CompositionContext, feature: messages.Feature) {
  describe(feature.name || "<unamed feature>", () => {
  before(function () {
  beforeHandler.call(this, context);
+ beforeAllHandler.call(this, context);
  });
 
  beforeEach(function () {
  beforeEachHandler.call(this, context);
  });
 
+ after(function () {
+ afterAllHandler.call(this, context);
+ });
+
  afterEach(function () {
  afterEachHandler.call(this, context);
  });
@@ -715,6 +720,31 @@ function beforeHandler(context: CompositionContext) {
  taskSpecEnvelopes(context);
 }
 
+function beforeAllHandler(this: Mocha.Context, context: CompositionContext) {
+ const { registry } = context;
+ let beforeAllHooks = registry.resolveBeforeAllHooks();
+ for(const beforeAllHook of beforeAllHooks) {
+ if (beforeAllHook) {
+ const hook = beforeAllHook;
+ cy.then(() => {
+ const start = createTimestamp();
+ return cy.wrap(start, { log: false });
+ })
+ .then((start) => {
+ runStepWithLogGroup({
+ fn: () => registry.runHook(this, hook),
+ keyword: "BeforeAll"
+ });
+
+ return cy.wrap(start, { log: false });
+ })
+ .then((start) => {
+ const end = createTimestamp();
+ });
+ }
+ }
+}
+
 function beforeEachHandler(context: CompositionContext) {
  assignRegistry(context.registry);
 }
@@ -946,6 +976,30 @@ function afterEachHandler(this: Mocha.Context, context: CompositionContext) {
  });
 }
 
+function afterAllHandler(this: Mocha.Context, context: CompositionContext) {
+ const { registry } = context;
+ let afterAllHooks = registry.resolveAfterAllHooks();
+ for(const afterAllHook of afterAllHooks) {
+ if (afterAllHook) {
+ const hook = afterAllHook;
+ cy.then(() => {
+ const start = createTimestamp();
+ return cy.wrap(start, { log: false });
+ })
+ .then((start) => {
+ runStepWithLogGroup({
+ fn: () => registry.runHook(this, hook),
+ keyword: "AfterAll"
+ });
+
+ return cy.wrap(start, { log: false });
+ })
+ .then((start) => {
+ const end = createTimestamp();
+ });
+ }
+ }
+}
 export default function createTests(
  registry: Registry,
  seed: number,
@@ -999,7 +1053,8 @@ export default function createTests(
  const tags = collectTagNames(pickle.tags);
  const beforeHooks = registry.resolveBeforeHooks(tags);
  const afterHooks = registry.resolveAfterHooks(tags);
-
+ const beforeAllHooks = registry.resolveBeforeAllHooks();
+ const afterAllHooks = registry.resolveAfterAllHooks();
  const hooksToStep = (hook: IHook): messages.TestStep => {
  return {
  id: createTestStepId({
@@ -1035,9 +1090,11 @@ export default function createTests(
  id: pickle.id,
  pickleId: pickle.id,
  testSteps: [
+ ...beforeAllHooks.map(hooksToStep),
  ...beforeHooks.map(hooksToStep),
  ...pickle.steps.map(pickleStepToTestStep),
  ...afterHooks.map(hooksToStep),
+ ...afterAllHooks.map(hooksToStep)
  ],
  };
  });

lib/entrypoint-browser.ts

@@ -126,6 +126,28 @@ function defineAfterStep(
  }
 }
 
+function defineBeforeAll(fn: IHookBody): void;
+function defineBeforeAll(
+ maybeFn?: IHookBody
+) {
+ if (typeof maybeFn === "function") {
+ getRegistry().defineBeforeAll(maybeFn);
+ } else {
+ throw new Error("Unexpected argument for BeforeAll hook");
+ }
+}
+
+function defineAfterAll(fn: IHookBody): void;
+function defineAfterAll(
+ maybeFn?: IHookBody
+) {
+ if (typeof maybeFn === "function") {
+ getRegistry().defineAfterAll(maybeFn);
+ } else {
+ throw new Error("Unexpected argument for AfterAll hook");
+ }
+}
+
 function createStringAttachment(
  data: string,
  mediaType: string,
@@ -205,6 +227,8 @@ export {
  defineAfter as After,
  defineBeforeStep as BeforeStep,
  defineAfterStep as AfterStep,
+ defineBeforeAll as BeforeAll,
+ defineAfterAll as AfterAll
 };
 
 /**

lib/entrypoint-node.ts

@@ -118,4 +118,20 @@ export function AfterStep(
  throw createUnimplemented();
 }
 
+export function BeforeAll(fn: IStepHookBody): void;
+export function BeforeAll(
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ maybeFn?: IStepHookBody
+) {
+ throw createUnimplemented();
+}
+
+export function AfterAll(fn: IStepHookBody): void;
+export function AfterAll(
+ // eslint-disable-next-line @typescript-eslint/no-unused-vars
+ maybeFn?: IStepHookBody
+) {
+ throw createUnimplemented();
+}
+
 export { default as DataTable } from "./data_table";

lib/registry.ts

@@ -40,7 +40,7 @@ export class MissingDefinitionError extends CypressCucumberError {}
 
 export class MultipleDefinitionsError extends CypressCucumberError {}
 
-export type ScenarioHookKeyword = "Before" | "After";
+export type ScenarioHookKeyword = "Before" | "After" | "BeforeAll" | "AfterAll";
 
 export type StepHookKeyword = "BeforeStep" | "AfterStep";
 
@@ -97,7 +97,6 @@ export class Registry {
  this.runStepDefininition = this.runStepDefininition.bind(this);
  this.defineParameterType = this.defineParameterType.bind(this);
  this.defineBefore = this.defineBefore.bind(this);
- this.defineAfter = this.defineAfter.bind(this);
 
  this.parameterTypeRegistry = new ParameterTypeRegistry();
  }
@@ -204,6 +203,14 @@ export class Registry {
  this.defineStepHook("AfterStep", options, fn);
  }
 
+ public defineBeforeAll(fn: IHookBody) {
+ this.defineHook("BeforeAll", {}, fn);
+ }
+
+ public defineAfterAll(fn: IHookBody) {
+ this.defineHook("AfterAll", {}, fn);
+ }
+
  public getMatchingStepDefinitions(text: string) {
  return this.stepDefinitions.filter((stepDefinition) =>
  stepDefinition.expression.match(text)
@@ -293,6 +300,13 @@ export class Registry {
  return this.resolveStepHooks("AfterStep", tags);
  }
 
+ public resolveBeforeAllHooks() {
+ return this.resolveHooks("BeforeAll", []);
+ }
+
+ public resolveAfterAllHooks() {
+ return this.resolveHooks("AfterAll", []);
+ }
  public runStepHook(
  world: Mocha.Context,
  hook: IStepHook,

test-d/entrypoint-browser.test-d.ts

@@ -25,6 +25,8 @@ import {
  After,
  BeforeStep,
  AfterStep,
+ BeforeAll,
+ AfterAll,
  DataTable,
 } from "../lib/entrypoint-browser";
 
@@ -138,6 +140,10 @@ defineParameterType({
  },
 });
 
+BeforeAll(function () {
+ expectType<Mocha.Context>(this);
+});
+
 Before(function () {
  expectType<Mocha.Context>(this);
 });
@@ -162,6 +168,10 @@ After({ tags: "foo" }, function () {
  expectType<Mocha.Context>(this);
 });
 
+AfterAll(function () {
+ expectType<Mocha.Context>(this);
+});
+
 BeforeStep(function ({
  pickle,
  pickleStep,

test-d/entrypoint-node.test-d.ts

@@ -25,6 +25,8 @@ import {
  After,
  BeforeStep,
  AfterStep,
+ BeforeAll,
+ AfterAll,
  DataTable,
 } from "../lib/entrypoint-node";