Merge branch 'VidhiRambhia/master'

Author: badeball

features/hooks_ordering.feature

@@ -2,6 +2,7 @@ Feature: hooks ordering
 
   Hooks should be executed in the following order:
    - before
+   - BeforeAll
    - beforeEach
    - Before
    - Background steps
@@ -10,14 +11,17 @@ Feature: hooks ordering
    - AfterStep (in reverse order)
    - After
    - afterEach
+   - AfterAll
    - after
 
+  @foo
   Scenario: with all hooks incrementing a counter
     Given a file named "cypress/e2e/a.feature" with:
       """
       Feature: a feature
         Background:
           Given a background step
+        @foo
         Scenario: a scenario
           Given an ordinary step
       """
@@ -28,50 +32,58 @@ Feature: hooks ordering
         Before,
         After,
         BeforeStep,
-        AfterStep
+        AfterStep,
+        BeforeAll,
+        AfterAll
       } = require("@badeball/cypress-cucumber-preprocessor")
       let counter;
       before(function() {
         counter = 0;
       })
+      BeforeAll(() => {
+        expect(counter++, "Expect BeforeAll() to be called after beforeEach()").to.equal(0)
+      })
       beforeEach(function() {
-        expect(counter++, "Expected beforeEach() to be called after before()").to.equal(0)
+        expect(counter++, "Expected beforeEach() to be called after before()").to.equal(1)
       })
       Before(function() {
-        expect(counter++, "Expected Before() to be called after beforeEach()").to.equal(1)
+        expect(counter++, "Expected Before() to be called after beforeEach()").to.equal(2)
       })
       Given("a background step", function() {
-        expect(counter++, "Expected a background step to be called after Before()").to.equal(2)
+        expect(counter++, "Expected a background step to be called after Before()").to.equal(3)
       })
       BeforeStep(function ({ pickleStep }) {
         if (pickleStep.text === "an ordinary step") {
-          expect(counter++, "Expected BeforeStep() to be called before ordinary steps").to.equal(3)
+          expect(counter++, "Expected BeforeStep() to be called before ordinary steps").to.equal(4)
         }
       })
       Given("an ordinary step", function() {
-        expect(counter++, "Expected an ordinary step to be called after a background step").to.equal(4)
+        expect(counter++, "Expected an ordinary step to be called after a background step").to.equal(5)
       })
       AfterStep(function ({ pickleStep }) {
         if (pickleStep.text === "an ordinary step") {
-          expect(counter++, "Expected AfterStep() to be called after ordinary steps").to.equal(6)
+          expect(counter++, "Expected AfterStep() to be called after ordinary steps").to.equal(7)
         }
       })
       AfterStep(function ({ pickleStep }) {
         if (pickleStep.text === "an ordinary step") {
-          expect(counter++, "Expected AfterStep() to be called after ordinary steps").to.equal(5)
+          expect(counter++, "Expected AfterStep() to be called after ordinary steps").to.equal(6)
         }
       })
       After(function() {
-        expect(counter++, "Expected After() to be called in reverse order of definition").to.equal(8)
+        expect(counter++, "Expected After() to be called in reverse order of definition").to.equal(9)
       })
       After(function() {
-        expect(counter++, "Expected After() to be called after ordinary steps").to.equal(7)
+        expect(counter++, "Expected After() to be called after ordinary steps").to.equal(8)
       })
       afterEach(function() {
-        expect(counter++, "Expected afterEach() to be called after After()").to.equal(9)
+        expect(counter++, "Expected afterEach() to be called after After()").to.equal(10)
+      })
+      AfterAll(function() {
+        expect(counter++, "Expected AfterAll() to be called after afterEach()").to.equal(11)
       })
       after(function() {
-        expect(counter++, "Expected after() to be called after afterEach()").to.equal(10)
+        expect(counter++, "Expected after() to be called after AfterAll()").to.equal(12)
       })
       """
     When I run cypress

lib/browser-runtime.ts

@@ -309,6 +309,10 @@ function createFeature(context: CompositionContext, feature: messages.Feature) {
       beforeEachHandler.call(this, context);
     });
 
+    after(function () {
+      afterAllHandler.call(this, context);
+    });
+
     afterEach(function () {
       afterEachHandler.call(this, context);
     });
@@ -765,13 +769,22 @@ function shouldSkipPickle(testFilter: Node, pickle: messages.Pickle) {
   return !testFilter.evaluate(tags) || tags.includes("@skip");
 }
 
-function beforeHandler(context: CompositionContext) {
+function beforeHandler(this: Mocha.Context, context: CompositionContext) {
   if (!retrieveInternalSuiteProperties()?.isEventHandlersAttached) {
     fail(
       "Missing preprocessor event handlers (this usally means you've not invoked `addCucumberPreprocessorPlugin()` or not returned the config object in `setupNodeEvents()`)"
     );
   }
-
+  // Handle BeforeAll hook
+  const { registry } = context;
+  const beforeAllHooks = registry.resolveBeforeAllHooks();
+  for (const beforeAllHook of beforeAllHooks) {
+    const hook = beforeAllHook;
+    runStepWithLogGroup({
+      fn: () => registry.runHook(this, hook),
+      keyword: "BeforeAll",
+    });
+  }
   taskSpecEnvelopes(context);
 }
 
@@ -1026,6 +1039,17 @@ function afterEachHandler(this: Mocha.Context, context: CompositionContext) {
   });
 }
 
+function afterAllHandler(this: Mocha.Context, context: CompositionContext) {
+  const { registry } = context;
+  const afterAllHooks = registry.resolveAfterAllHooks();
+  for (const afterAllHook of afterAllHooks) {
+    const hook = afterAllHook;
+    runStepWithLogGroup({
+      fn: () => registry.runHook(this, hook),
+      keyword: "AfterAll",
+    });
+  }
+}
 export default function createTests(
   registry: Registry,
   seed: number,
@@ -1079,7 +1103,6 @@ export default function createTests(
       const tags = collectTagNames(pickle.tags);
       const beforeHooks = registry.resolveBeforeHooks(tags);
       const afterHooks = registry.resolveAfterHooks(tags);
-
       const hooksToStep = (hook: IHook): messages.TestStep => {
         return {
           id: createTestStepId({

lib/entrypoint-browser.ts

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

lib/entrypoint-node.ts

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

lib/public-member-types.ts

@@ -12,7 +12,7 @@ export interface IHookOptions {
 }
 
 export interface IHookBody {
-  (this: Mocha.Context, options: IHookParameter): void;
+  (this: Mocha.Context, options?: IHookParameter): void;
 }
 
 export interface IHookParameter {

lib/registry.ts

@@ -42,7 +42,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";
 
@@ -208,6 +208,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)
@@ -279,7 +287,7 @@ export class Registry {
     return this.resolveHooks("After", tags).reverse();
   }
 
-  public runHook(world: Mocha.Context, hook: IHook, options: IHookParameter) {
+  public runHook(world: Mocha.Context, hook: IHook, options?: IHookParameter) {
     return hook.implementation.call(world, options);
   }
 
@@ -297,6 +305,13 @@ export class Registry {
     return this.resolveStepHooks("AfterStep", tags).reverse();
   }
 
+  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", name: "bar" }, 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";
 
@@ -138,6 +140,10 @@ defineParameterType({
   },
 });
 
+BeforeAll(function () {
+  expectType<Mocha.Context>(this);
+});
+
 Before(function () {
   expectType<Mocha.Context>(this);
 });
@@ -162,6 +168,10 @@ After({ tags: "foo", name: "bar" }, function () {
   expectType<Mocha.Context>(this);
 });
 
+AfterAll(function () {
+  expectType<Mocha.Context>(this);
+});
+
 BeforeStep(function ({
   pickle,
   pickleStep,