@lynxwall/cucumber-tsflow 6.3.0 → 6.5.0

package/README.md

@@ -313,7 +313,7 @@ If using VSCode to edit your project the following launch configurations can be
 Bindings provide the automation that connects a specification step in a Gherkin feature file to some code that
 executes for that step. When using Cucumber with TypeScript you can define this automation using a 'binding' class:
 
-```javascript
+```typescript
 import { binding } from "@lynxwall/cucumber-tsflow";
 
 @binding()
@@ -327,7 +327,7 @@ export default class MySteps {
 Step definitions can be bound to automation code in a 'binding' class by implementing a public function that is
 bound with a 'given', 'when' or 'then' binding decorator:
 
-```javascript
+```typescript
 import { binding, given, when, then } from "@lynxwall/cucumber-tsflow";
 
 @binding()
@@ -362,7 +362,7 @@ Scenario: Boolean type supported
 
 The associated step definition replaces `true` in this scenario with a `{boolean}` expression as shown below:
 
-```javascript
+```typescript
 @given('I pass {boolean} into a step')
 iPassbooleanIntoAStep(boolean: boolean): any {
 	this.boolValue = boolean;
@@ -386,7 +386,7 @@ More information on Cucumber Expressions and Custom Parameter Types can be found
 Step definitions can be conditionally selected for execution based on the tags of the scenario by supplying tags when using the binding
 decorators:
 
-```javascript
+```typescript
 @given('I perform a search using the value {string}')
 public givenAValueBasedSearch(searchValue: string): void {
     ...
@@ -506,7 +506,7 @@ If it doesn't already exist, create a file named cucumber.json at the root of yo
 
 The following example shows how to configure the behave formatter in cucumber.json. The tsflow-snippet-syntax module is configured as the default snippet syntax and does not require configuration. However, you can override the snippet syntax as documented here: <https://github.com/cucumber/cucumber-js/blob/v8.0.0/docs/custom_snippet_syntaxes.md>
 
-```javascript
+```typescript
 {
 	"default": {
 		"format": [
@@ -520,7 +520,7 @@ The following example shows how to configure the behave formatter in cucumber.js
 
 The following example shows how to configure the bamboo junit formatter in cucumber.json. This differs from the standard cucumber junit formatter in that "pending" and "undefined" tests do not get classified as failures, instead they are classified as skips
 
-```javascript
+```typescript
 {
 	"default": {
 		"format": [
@@ -530,73 +530,218 @@ The following example shows how to configure the bamboo junit formatter in cucum
 }
 ```
 
-## Sharing Data between Bindings
+## Sharing Data between Steps and Bindings
 
 ### Context Injection
 
-Like 'specflow', cucumber-tsflow supports a simple dependency injection framework that will instantitate and inject class instances into 'binding' classes for each execuing scenario.
+Like 'specflow', cucumber-tsflow supports a simple dependency injection framework that will instantiate and inject class instances into 'binding' classes for each executing scenario.
 
-To use context injection:
+Each scenario in a feature will get a new instance of the *Context* object when the steps associated with a scenario are executed. Hooks and steps used by the scenario will have access to the same instance of a "Scenario Context" during execution of the test steps. In addition, if steps of a scenario are implemented in separate bindings, those steps will still have access to the same instance of the *Context* object created for the scenario.
 
-- Create simple classes representing the shared data (they _must_ have default constructors)
-- Define a constructor on the 'binding' classes that will require the shared data that accepts the context objects as parameters
-- Update the `@binding()` decorator to indicate the types of context objects that are required by the 'binding' class
+**Recent Updates:**
 
-```javascript
+- versions >= 6.5.0
+  - Context classes now support an `initialize()` function that can be defined synchronous or asynchronous. The `initialize()` function is called after the `BeforeAll` hook and before any other hooks or steps. This provides the ability to initialize a scenario context before any tests are executed with support for async operations.
+  - Context classes have always supported a `dispose()` function for cleanup. However, with latest updates the `dispose()` function can be defined synchronously or asynchronously.
+
+- versions >= 6.4.0
+  - The current Cucumber World object is now available as a constructor parameter on all classes defined for Context Injection. For more information on the World object see: [Access to Cucumber.js World object](#access-to-cucumber.js-world-object).
+
+
+### Using Context Injection
+
+With Context Injection you first need to define one or more classes that will be injected into a binding instance. Next, you'll need to add the context types to the `@binding` decorator and implement a constructor that passes initialized instances of the context type into the binding instance.
+
+**Defining a Context class:**
+
+- Create a simple *Context* class representing the shared data. The class can have no constructor or a default empty constructor. However, to access the Cucumber World object you should define a constructor as shown in the example below.
+
+**Synchronous example:**
+
+```typescript
+import { World } from '@cucumber/cucumber';
+
+export class ScenarioContext {
+	public world: World;
+	public someValue = '';
+	private id: string = '';
+
+	constructor(worldObj: World) {
+		this.world = worldObj;
+	}
+	public initialize(): void {
+		this.id = this.makeid(5);
+		console.log(`Sync init: ${this.id}`);
+	}
+	public dispose(): void {
+		console.log(`Sync dispose: ${this.id}`);
+	}
+	makeid(length: number) {
+		...
+		return result;
+	}
+}
+```
+
+**Asynchronous example:**
+
+```typescript
+import { World } from '@cucumber/cucumber';
+
+export class ScenarioContext {
+	public world: World;
+	public someValue = '';
+	private id: string = '';
+
+	constructor(worldObj: World) {
+		this.world = worldObj;
+	}
+	public async initialize(): Promise<void> {
+		this.id = this.makeid(5);
+		await this.logTest(`Async init: ${this.id}`);
+	}
+	public async dispose(): Promise<void> {
+		await this.logTest(`Async dispose: ${this.id}`);
+	}
+	async logTest(text: string): Promise<void> {
+		await Promise.resolve(console.log(text));
+	}
+	makeid(length: number) {
+		...
+		return result;
+	}
+}
+```
+
+
+
+**Initialize Binding in Step class:**
+
+- Update the `@binding()` decorator to indicate the types of context objects that are required by the 'binding' class. You can include up to nine separate *Context* objects.
+- Define a constructor on the `@binding` class with steps that need access to the shared data that accepts one or more context objects as parameters based on initialization of the `@binding` decorator.
+
+**Single Context class example:**
+
+```typescript
+import { binding, given, when } from '@lynxwall/cucumber-tsflow';
+import { ScenarioContext } from '../fixtures/scenario-context';
+import { expect } from 'chai';
+
+@binding([ScenarioContext])
+export default class InjectionTestSteps1 {
+	constructor(private context: ScenarioContext) {}
+
+	@given('The Workspace is available and valid')
+	theWorkspaceIsAvailableAndValid() {
+		expect(this.context).not.to.be.undefined;
+		expect(this.context.world).not.to.be.undefined;
+	}
+
+	@when('I change the workspace in one step definition class')
+	whenIChangeTheWorkspaceInOneStep() {
+		this.context.someValue = 'value changed';
+	}
+}
+```
+
+**Multiple Context classes example:**
+
+```typescript
 import { binding, given, when } from '@lynxwall/cucumber-tsflow';
-import { Workspace } from './workspace';
+import { ScenarioContext } from '../fixtures/scenario-context';
+import { SyncContext } from '../fixtures/sync-context';
 import { expect } from 'chai';
 
-@binding([Workspace])
+@binding([ScenarioContext, SyncContext])
 export default class InjectionTestSteps1 {
-	constructor(private workspace: Workspace) {}
+	constructor(private context: ScenarioContext, private syncContext: SyncContext) {}
 
 	@given('The Workspace is available and valid')
 	theWorkspaceIsAvailableAndValid() {
-		expect(this.workspace).not.to.be.undefined;
-		expect(this.workspace.world).not.to.be.undefined;
+		expect(this.context).not.to.be.undefined;
+		expect(this.context.world).not.to.be.undefined;
+
+		expect(this.syncContext).not.to.be.undefined;
+		expect(this.syncContext.world).not.to.be.undefined;
 	}
 
 	@when('I change the workspace in one step definition class')
 	whenIChangeTheWorkspaceInOneStep() {
-		this.workspace.someValue = 'value changed';
+		this.context.someValue = 'value changed';
 	}
 }
 ```
 
+
+
 ### Access to Cucumber.js World object
 
-The context object that you inject can also be configured to access the [World](https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/world.md) object from Cucumber.js, which provides a method for adding attachments, a method for logging information from hooks/steps and an object of parameters passed in via configuration.
+The context object that you inject can also be configured to access the [World](https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/world.md) object from Cucumber.js, which provides the following:
 
-The first step is to define a world property on the class that you're injecting:
+- `attach`: a method for adding [attachments](https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/attachments.md) to hooks/steps
+- `log`: a method for [logging](https://github.com/cucumber/cucumber-js/blob/main/docs/support_files/attachments.md#logging) information from hooks/steps
+- `parameters`: an object of parameters passed in via configuration
 
-```javascript
+Starting with version **6.4.0** the Cucumber World object is now passed into a *Context* class as a constructor parameter as shown below:
+
+```typescript
+import { World } from '@cucumber/cucumber';
+
+export class ScenarioContext {
+	public world: World;
+	public someValue = '';
+
+	constructor(worldObj: World) {
+		this.world = worldObj;
+	}
+
+	public dispose(): void {
+		this.someValue = '';
+	}
+}
+```
+
+In the example shown above, the world object instance passed in to the constructor is saved to a variable in the `ScenarioContext` class. This class is automatically initialized and injected into the constructor of a binding class when tests are executed. As a result, the world object, with access to world context parameters, logging and attachments, is available to most hooks and all steps within a test.
+
+**NOTE:** `BeforeAll` and `AfterAll` hooks do not have access to the scenario context.
+
+*Context* classes, as demonstrated by the `ScenarioContext` example above, also support a `dispose()` function that is called when the execution of a test scenario is complete. 
+
+With instance initialization, and dispose functionality, you have the ability to initialize common support operations and data needed for scenario test runs, and cleanup any resources when scenario test runs are complete.
+
+### Access to the World object without using a constructor
+
+**NOTE:** This approach of accessing the Cucumber World object is still supported. However, the ability to access the world object during *Context* initialization provides much better control over when context data is initialized versus relying on execution of a hook. As a result, using a `@before` hook as shown below is not recommended.
+
+With this approach, you would define a world property on simple *Context* class that you're injecting:
+
+```typescript
 import { World } from '@cucumber/cucumber';
 
-export class Workspace {
+export class ScenarioContext {
 	public world!: World;
 	public someValue = '';
 }
 ```
 
-Next you'll need to initialize the world property in a **_@before_** hook so that it's available to all steps in a scenario. My approach is to add a new file to the steps folder that is dedicated to initializing the class (Workspace in this example) in a **_@before_** hook.
+Next you'll need to initialize the world property in a `@before` hook so that it's available to all steps in a scenario. This is done by adding a new file to the steps folder that is dedicated to initializing the class (`ScenarioContext` in this example) in a `@before` hook.
 
 For this example I've added a file named world-context.ts with the following content:
 
-```javascript
+```typescript
 import { binding, before } from '@lynxwall/cucumber-tsflow';
-import { Workspace } from './workspace';
+import { ScenarioContext } from '../fixtures/scenario-context';
 import { World } from '@cucumber/cucumber';
 
-@binding([Workspace])
+@binding([ScenarioContext])
 export default class WorldContext {
 	_worldObj?: World;
 
-	constructor(private workspace: Workspace) {}
+	constructor(private context: ScenarioContext) {}
 
 	@before()
 	beforeScenario() {
-		this.workspace.world = this._worldObj as World;
+		this.context.world = this._worldObj as World;
 	}
 }
 ```

package/lib/cucumber/binding-decorator.js

@@ -91,7 +91,7 @@ function bindStepDefinition(stepBinding) {
                 throw new Error(`Cannot find matched step definition for ${stepBinding.stepPattern.toString()} with tag ${scenarioContext.scenarioInfo.tags} in binding registry`);
             }
             const contextTypes = bindingRegistry.getContextTypesForTarget(matchingStepBindings[0].targetPrototype);
-            const bindingObject = scenarioContext.getOrActivateBindingClass(matchingStepBindings[0].targetPrototype, contextTypes);
+            const bindingObject = scenarioContext.getOrActivateBindingClass(matchingStepBindings[0].targetPrototype, contextTypes, this);
             bindingObject._worldObj = this;
             return bindingObject[matchingStepBindings[0].targetPropertyKey].apply(bindingObject, arguments);
         }
@@ -133,7 +133,7 @@ function bindHook(stepBinding) {
             const scenarioContext = global.messageCollector.getHookScenarioContext(arg);
             if (scenarioContext) {
                 const contextTypes = binding_registry_1.BindingRegistry.instance.getContextTypesForTarget(stepBinding.targetPrototype);
-                const bindingObject = scenarioContext.getOrActivateBindingClass(stepBinding.targetPrototype, contextTypes);
+                const bindingObject = scenarioContext.getOrActivateBindingClass(stepBinding.targetPrototype, contextTypes, this);
                 bindingObject._worldObj = this;
                 return bindingObject[stepBinding.targetPropertyKey].apply(bindingObject, arguments);
             }
@@ -178,4 +178,4 @@ function bindHook(stepBinding) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cucumber/binding-registry.d.ts

@@ -63,6 +63,7 @@ export declare class BindingRegistry {
      * @returns An array of [[StepBinding]] that map to the given step pattern and set of tag names.
      */
     getStepBindings(stepPattern: StepPattern, tags: TagName[]): StepBinding[];
+    getStepBindingByCucumberKey(cucumberKey: string): StepBinding | undefined;
     /**
      * Updates the SupportCodeLibrary from Cucumber with
      * callsite information from tsflow bindings

package/lib/cucumber/binding-registry.js

@@ -152,6 +152,21 @@ class BindingRegistry {
         }
         return this.mapTagNamesToStepBindings(['*'], tagMap);
     }
+    getStepBindingByCucumberKey(cucumberKey) {
+        let result = undefined;
+        for (const [_, binding] of this._targetBindings) {
+            for (const stepBinding of binding.stepBindings) {
+                if (stepBinding.cucumberKey === cucumberKey) {
+                    result = stepBinding;
+                    break;
+                }
+            }
+            if (result) {
+                break;
+            }
+        }
+        return result;
+    }
     /**
      * Updates the SupportCodeLibrary from Cucumber with
      * callsite information from tsflow bindings
@@ -213,4 +228,4 @@ class BindingRegistry {
     }
 }
 exports.BindingRegistry = BindingRegistry;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"binding-registry.js","sourceRoot":"","sources":["../../src/cucumber/binding-registry.ts"],"names":[],"mappings":"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"}

package/lib/cucumber/managed-scenario-context.d.ts

@@ -1,5 +1,6 @@
 import { ScenarioContext, ScenarioInfo } from '../types/scenario-context';
 import { ContextType } from '../types/types';
+import { World } from '@cucumber/cucumber';
 /**
  * Represents a [[ScenarioContext]] implementation that manages a collection of context objects that
  * are created and used by binding classes during a running Cucumber scenario.
@@ -13,9 +14,38 @@ export declare class ManagedScenarioContext implements ScenarioContext {
      *
      */
     get scenarioInfo(): ScenarioInfo;
-    getOrActivateBindingClass(targetPrototype: any, contextTypes: ContextType[]): any;
-    dispose(): void;
+    getOrActivateBindingClass(targetPrototype: any, contextTypes: ContextType[], worldObj: World): any;
+    /**
+     * If context objects are passed into our step, this function will
+     * call initialize on the context objects only once.
+     * Using Promise.resolve so that initialize can be synchronous or async.
+     */
+    initialize(): Promise<void>;
+    /**
+     * All objects support dispose, which is executed when a
+     * test run is ended. Using Promise.resolve to support
+     * synchronous or async functions.
+     */
+    dispose(): Promise<void>;
     private activateBindingClass;
+    /**
+     * Get or activate any object
+     *
+     * @param targetPrototype prototype for the object
+     * @param activatorFunc callback function used to create an instance of the object
+     * @param optional optional parameter passed into constructors
+     * @returns
+     */
     private getOrActivateObject;
+    /**
+     * Get or activate Context objects. Marks an object as a context
+     * object in ActiveInfo to let the system know it supports an initialize function.
+     *
+     * @param targetPrototype prototype for the object
+     * @param activatorFunc callback function used to create an instance of the object
+     * @param optional optional parameter passed into constructors
+     * @returns
+     */
+    private getOrActivateContext;
 }
 export * from '../types/scenario-context';

package/lib/cucumber/managed-scenario-context.js

@@ -20,6 +20,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManagedScenarioContext = void 0;
 const underscore_1 = __importDefault(require("underscore"));
 const scenario_context_1 = require("../types/scenario-context");
+class ActiveInfo {
+    constructor(obj, isContext = false) {
+        this.activeObject = obj;
+        this.isContext = isContext;
+    }
+    activeObject;
+    isContext;
+    initialized = false;
+}
 /**
  * Represents a [[ScenarioContext]] implementation that manages a collection of context objects that
  * are created and used by binding classes during a running Cucumber scenario.
@@ -37,19 +46,37 @@ class ManagedScenarioContext {
     get scenarioInfo() {
         return this._scenarioInfo;
     }
-    getOrActivateBindingClass(targetPrototype, contextTypes) {
+    getOrActivateBindingClass(targetPrototype, contextTypes, worldObj) {
         return this.getOrActivateObject(targetPrototype, () => {
-            return this.activateBindingClass(targetPrototype, contextTypes);
+            return this.activateBindingClass(targetPrototype, contextTypes, worldObj);
         });
     }
-    dispose() {
-        this._activeObjects.forEach((value) => {
-            if (typeof value.dispose === 'function') {
-                value.dispose();
+    /**
+     * If context objects are passed into our step, this function will
+     * call initialize on the context objects only once.
+     * Using Promise.resolve so that initialize can be synchronous or async.
+     */
+    async initialize() {
+        for (const [_key, value] of this._activeObjects) {
+            if (value.isContext && !value.initialized && typeof value.activeObject.initialize === 'function') {
+                await Promise.resolve(value.activeObject.initialize());
+                value.initialized = true;
             }
-        });
+        }
+    }
+    /**
+     * All objects support dispose, which is executed when a
+     * test run is ended. Using Promise.resolve to support
+     * synchronous or async functions.
+     */
+    async dispose() {
+        for (const [_key, value] of this._activeObjects) {
+            if (typeof value.activeObject.dispose === 'function') {
+                await Promise.resolve(value.activeObject.dispose());
+            }
+        }
     }
-    activateBindingClass(targetPrototype, contextTypes) {
+    activateBindingClass(targetPrototype, contextTypes, worldObj) {
         const invokeBindingConstructor = (args) => {
             switch (contextTypes.length) {
                 case 0:
@@ -76,21 +103,47 @@ class ManagedScenarioContext {
                     return new targetPrototype.constructor(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
             }
         };
-        const contextObjects = underscore_1.default.map(contextTypes, contextType => this.getOrActivateObject(contextType.prototype, () => {
-            return new contextType();
-        }));
+        const contextObjects = underscore_1.default.map(contextTypes, contextType => this.getOrActivateContext(contextType.prototype, (worldObj) => {
+            return new contextType(worldObj);
+        }, worldObj));
         return invokeBindingConstructor(contextObjects);
     }
-    getOrActivateObject(targetPrototype, activatorFunc) {
-        let activeObject = this._activeObjects.get(targetPrototype);
+    /**
+     * Get or activate any object
+     *
+     * @param targetPrototype prototype for the object
+     * @param activatorFunc callback function used to create an instance of the object
+     * @param optional optional parameter passed into constructors
+     * @returns
+     */
+    getOrActivateObject(targetPrototype, activatorFunc, optional) {
+        let activeObject = this._activeObjects.get(targetPrototype)?.activeObject;
+        if (activeObject) {
+            return activeObject;
+        }
+        activeObject = activatorFunc(optional);
+        this._activeObjects.set(targetPrototype, new ActiveInfo(activeObject));
+        return activeObject;
+    }
+    /**
+     * Get or activate Context objects. Marks an object as a context
+     * object in ActiveInfo to let the system know it supports an initialize function.
+     *
+     * @param targetPrototype prototype for the object
+     * @param activatorFunc callback function used to create an instance of the object
+     * @param optional optional parameter passed into constructors
+     * @returns
+     */
+    getOrActivateContext(targetPrototype, activatorFunc, optional) {
+        let activeObject = this._activeObjects.get(targetPrototype)?.activeObject;
         if (activeObject) {
             return activeObject;
         }
-        activeObject = activatorFunc();
-        this._activeObjects.set(targetPrototype, activeObject);
+        activeObject = activatorFunc(optional);
+        this._activeObjects.set(targetPrototype, new ActiveInfo(activeObject, true));
         return activeObject;
     }
 }
 exports.ManagedScenarioContext = ManagedScenarioContext;
 __exportStar(require("../types/scenario-context"), exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cucumber/message-collector.d.ts

@@ -28,6 +28,8 @@ export default class MessageCollector {
     private testCaseAttemptDataMap;
     readonly undefinedParameterTypes: messages.UndefinedParameterType[];
     private testCaseRunningMap;
+    private collectorEvents;
+    onTestCaseEnd(Handler: (testCaseFinished: messages.TestCaseFinished) => void): void;
     addPickleAndTestCase(pickle: messages.Pickle, testCase: messages.TestCase): void;
     hasFailures(): boolean;
     getGherkinDocument(uri: string): messages.GherkinDocument;
@@ -64,7 +66,7 @@ export default class MessageCollector {
      * this message to dispose and clear the ScenarioContext
      * @param testCaseFinished
      */
-    private endTestCase;
+    endTestCase(testCaseStartedId: string): Promise<void>;
     /**
      * Uses the testCaleId passed in to find the associated Pickle (scenario)
      * @param testCaseId

package/lib/cucumber/message-collector.js

@@ -22,6 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const messages = __importStar(require("@cucumber/messages"));
 const value_checker_1 = require("@cucumber/cucumber/lib/value_checker");
@@ -29,6 +32,7 @@ const managed_scenario_context_1 = require("./managed-scenario-context");
 const utils_1 = require("./utils");
 const helpers_1 = require("../utils/helpers");
 const messages_1 = require("@cucumber/messages");
+const events_1 = __importDefault(require("events"));
 /**
  * Custom implementation of the EventDataCollector from cucumber.js
  *
@@ -46,6 +50,10 @@ class MessageCollector {
     testCaseAttemptDataMap = {};
     undefinedParameterTypes = [];
     testCaseRunningMap = {};
+    collectorEvents = new events_1.default();
+    onTestCaseEnd(Handler) {
+        this.collectorEvents.on('testCaseEnd', Handler);
+    }
     // Used during parallel execution to add the current pickle and testCase
     // to a new Worker instance of the MessageCollector
     addPickleAndTestCase(pickle, testCase) {
@@ -114,7 +122,6 @@ class MessageCollector {
         }
         else if (envelope.testCaseFinished) {
             this.storeTestCaseResult(envelope.testCaseFinished);
-            this.endTestCase(envelope.testCaseFinished);
         }
     }
     initTestCaseAttempt(testCaseStarted) {
@@ -215,12 +222,12 @@ class MessageCollector {
      * this message to dispose and clear the ScenarioContext
      * @param testCaseFinished
      */
-    endTestCase(testCaseFinished) {
-        const testCase = this.testCaseRunningMap[testCaseFinished.testCaseStartedId];
+    async endTestCase(testCaseStartedId) {
+        const testCase = this.testCaseRunningMap[testCaseStartedId];
         if (testCase) {
             const scenario = this.getScenarioForTest(testCase.testCaseId);
             if (scenario && scenario.scenarioContext) {
-                scenario.scenarioContext.dispose();
+                await scenario.scenarioContext.dispose();
                 scenario.scenarioContext = undefined;
             }
         }
@@ -248,4 +255,4 @@ class MessageCollector {
     }
 }
 exports.default = MessageCollector;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-collector.js","sourceRoot":"","sources":["../../src/cucumber/message-collector.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-collector.js","sourceRoot":"","sources":["../../src/cucumber/message-collector.ts"],"names":[],"mappings":"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"}

package/lib/cucumber/parallel/worker.js

@@ -9,7 +9,7 @@ const url_1 = require("url");
 const index_1 = __importDefault(require("@cucumber/cucumber/lib/support_code_library_builder/index"));
 const run_test_run_hooks_1 = require("@cucumber/cucumber/lib/runtime/run_test_run_hooks");
 const stopwatch_1 = require("@cucumber/cucumber/lib/runtime/stopwatch");
-const test_case_runner_1 = __importDefault(require("@cucumber/cucumber/lib/runtime/test_case_runner"));
+const test_case_runner_1 = __importDefault(require("../test-case-runner"));
 const message_collector_1 = __importDefault(require("../message-collector"));
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { importer } = require('@cucumber/cucumber/lib/importer');
@@ -101,4 +101,4 @@ class Worker {
     }
 }
 exports.default = Worker;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2N1Y3VtYmVyL3BhcmFsbGVsL3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLGlEQUFpRDtBQUNqRCxtQ0FBc0M7QUFDdEMsNkJBQW9DO0FBQ3BDLHNHQUFrRztBQUVsRywwRkFBMEc7QUFDMUcsd0VBQWtFO0FBQ2xFLDJFQUFpRDtBQU9qRCw2RUFBb0Q7QUFFcEQsOERBQThEO0FBQzlELE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxPQUFPLENBQUMsaUNBQWlDLENBQUMsQ0FBQztBQUNoRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEdBQUcsc0JBQVcsQ0FBQztBQUs3Qjs7O0dBR0c7QUFDSCxNQUFxQixNQUFNO0lBQ1QsR0FBRyxDQUFTO0lBQ1osSUFBSSxDQUFnQjtJQUVwQixFQUFFLENBQVM7SUFDWCxnQkFBZ0IsQ0FBZTtJQUN4QyxpQkFBaUIsR0FBWSxLQUFLLENBQUM7SUFDMUIsS0FBSyxDQUFvQjtJQUN6QixXQUFXLENBQWlCO0lBQ3JDLGtCQUFrQixDQUF1QjtJQUN6QyxlQUFlLENBQU07SUFDckIsZUFBZSxDQUFvQjtJQUUzQyxZQUFZLEVBQ1gsR0FBRyxFQUNILElBQUksRUFDSixFQUFFLEVBQ0YsV0FBVyxFQU1YO1FBQ0EsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUM7UUFDYixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksRUFBRSxDQUFDO1FBQ3BCLElBQUksQ0FBQyxHQUFHLEdBQUcsR0FBRyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLGdCQUFnQixHQUFHLElBQUkscUJBQVksRUFBRSxDQUFDO1FBQzNDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLENBQUMsVUFBVSxFQUFFLENBQUMsUUFBMkIsRUFBRSxFQUFFO1lBQ3BFLElBQUksQ0FBQyxXQUFXLENBQUM7Z0JBQ2hCLFlBQVksRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQzthQUN0QyxDQUFDLENBQUM7UUFDSixDQUFDLENBQUMsQ0FBQztRQUNILCtFQUErRTtRQUMvRSw0REFBNEQ7UUFDNUQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLDJCQUFnQixFQUFFLENBQUM7UUFDaEQsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsQ0FBQyxVQUFVLEVBQUUsZ0JBQWdCLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUM7UUFDNUYsTUFBTSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO0lBQzVDLENBQUM7SUFFRCxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQ2hCLGlCQUFpQixFQUNqQixjQUFjLEVBQ2QsWUFBWSxFQUNaLFdBQVcsRUFDWCxjQUFjLEVBQ2QsT0FBTyxFQUNtQjtRQUMxQixlQUF5QixDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN0RCxjQUFjLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFDOUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQzVDLEtBQUssTUFBTSxJQUFJLElBQUksV0FBVyxFQUFFO1lBQy9CLE1BQU0sUUFBUSxDQUFDLElBQUEsbUJBQWEsRUFBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1NBQ3BDO1FBQ0QsSUFBSSxDQUFDLGtCQUFrQixHQUFHLGVBQXlCLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBRTdFLElBQUksQ0FBQyxlQUFlLEdBQUcsT0FBTyxDQUFDLGVBQWUsQ0FBQztRQUMvQyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsaUJBQWlCLENBQUM7UUFDM0MsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFBLHdDQUFtQixFQUN6QyxPQUFPLENBQUMsTUFBTSxFQUNkLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxjQUFjLEVBQ3RDLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRSxFQUFFLENBQUMsR0FBRyxJQUFJLDJCQUEyQixJQUFJLENBQUMsRUFBRSxzQkFBc0IsUUFBUSxFQUFFLENBQzdGLENBQUM7UUFDRixNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLDRCQUE0QixFQUFFLGFBQWEsQ0FBQyxDQUFDO1FBQ2hHLElBQUksQ0FBQyxXQUFXLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRUQsS0FBSyxDQUFDLFFBQVE7UUFDYixJQUFJLElBQUksQ0FBQyxrQkFBa0IsSUFBSSxJQUFJLENBQUMsZUFBZSxFQUFFO1lBQ3BELE1BQU0sSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsMkJBQTJCLEVBQUUsYUFBYSxDQUFDLENBQUM7U0FDL0Y7UUFDRCxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2QsQ0FBQztJQUVELEtBQUssQ0FBQyxjQUFjLENBQUMsT0FBdUI7UUFDM0MsSUFBSSxPQUFPLENBQUMsVUFBVSxFQUFFO1lBQ3ZCLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7U0FDMUM7YUFBTSxJQUFJLE9BQU8sQ0FBQyxRQUFRLEVBQUU7WUFDNUIsTUFBTSxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7U0FDdEI7YUFBTSxJQUFJLE9BQU8sQ0FBQyxHQUFHLEVBQUU7WUFDdkIsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztTQUNwQztJQUNGLENBQUM7SUFFRCxLQUFLLENBQUMsV0FBVyxDQUFDLEVBQUUsZUFBZSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQXFCO1FBQ2pHLDZEQUE2RDtRQUM3RCxpQ0FBaUM7UUFDakMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLG9CQUFvQixDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsQ0FBQztRQUMvRCxNQUFNLFNBQVMsR0FBRyxJQUFBLGtCQUFNLEVBQUMsT0FBTyxDQUFDLENBQUM7UUFDbEMsTUFBTSxjQUFjLEdBQUcsSUFBSSwwQkFBYyxDQUFDO1lBQ3pDLGdCQUFnQixFQUFFLElBQUksQ0FBQyxnQkFBZ0I7WUFDdkMsU0FBUztZQUNULGVBQWU7WUFDZixLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUs7WUFDakIsTUFBTTtZQUNOLFFBQVE7WUFDUixPQUFPO1lBQ1AsSUFBSTtZQUNKLGlCQUFpQixFQUFFLElBQUksQ0FBQyxpQkFBaUI7WUFDekMsa0JBQWtCLEVBQUUsSUFBSSxDQUFDLGtCQUF5QztZQUNsRSxlQUFlLEVBQUUsSUFBSSxDQUFDLGVBQWU7U0FDckMsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxjQUFjLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDM0IsSUFBSSxDQUFDLFdBQVcsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ25DLENBQUM7Q0FDRDtBQTNHRCx5QkEyR0MifQ==

package/lib/cucumber/test-case-runner.d.ts

@@ -0,0 +1,48 @@
+import { INewTestCaseRunnerOptions } from '@cucumber/cucumber/lib/runtime/test_case_runner';
+import * as messages from '@cucumber/messages';
+import { ITestCaseHookParameter } from '@cucumber/cucumber/lib/support_code_library_builder/types';
+import TestCaseHookDefinition from '@cucumber/cucumber/lib/models/test_case_hook_definition';
+import TestStepHookDefinition from '@cucumber/cucumber/lib/models/test_step_hook_definition';
+import { IDefinition } from '@cucumber/cucumber/lib/models/definition';
+import { StepBinding } from '../types/step-binding';
+import { ManagedScenarioContext } from './managed-scenario-context';
+export default class TestCaseRunner {
+    private readonly attachmentManager;
+    private currentTestCaseStartedId?;
+    private currentTestStepId?;
+    private readonly eventBroadcaster;
+    private readonly stopwatch;
+    private readonly gherkinDocument;
+    private readonly newId;
+    private readonly pickle;
+    private readonly testCase;
+    private readonly maxAttempts;
+    private readonly skip;
+    private readonly filterStackTraces;
+    private readonly supportCodeLibrary;
+    private testStepResults?;
+    private world;
+    private readonly worldParameters;
+    private bindingRegistry;
+    constructor({ eventBroadcaster, stopwatch, gherkinDocument, newId, pickle, testCase, retries, skip, filterStackTraces, supportCodeLibrary, worldParameters }: INewTestCaseRunnerOptions);
+    resetTestProgressData(): void;
+    getBeforeStepHookDefinitions(): TestStepHookDefinition[];
+    getAfterStepHookDefinitions(): TestStepHookDefinition[];
+    getWorstStepResult(): messages.TestStepResult;
+    invokeStep(stepParam: messages.PickleStep | null, stepDefinition: IDefinition, hookParameter?: any): Promise<messages.TestStepResult>;
+    isSkippingSteps(): boolean;
+    shouldSkipHook(isBeforeHook: boolean): boolean;
+    aroundTestStep(testStepId: string, runStepFn: () => Promise<messages.TestStepResult>): Promise<void>;
+    run(): Promise<messages.TestStepResultStatus>;
+    runAttempt(attempt: number, moreAttemptsRemaining: boolean): Promise<boolean>;
+    runHook(hookDefinition: TestCaseHookDefinition, hookParameter: ITestCaseHookParameter, isBeforeHook: boolean): Promise<messages.TestStepResult>;
+    runStepHooks(stepHooks: TestStepHookDefinition[], pickleStep: messages.PickleStep, stepResult?: messages.TestStepResult): Promise<messages.TestStepResult[]>;
+    runStep(pickleStep: messages.PickleStep, testStep: messages.TestStep): Promise<messages.TestStepResult>;
+    /**
+     * Helper used to initialize any context types that are passed into
+     * a binding class before any hooks or steps are executed.
+     * @param stepBinding
+     * @param scenarioContext
+     */
+    initializeContext(stepBinding: StepBinding, scenarioContext: ManagedScenarioContext): Promise<void>;
+}

package/lib/cucumber/test-case-runner.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@cucumber/cucumber/lib/runtime/helpers");
+const index_1 = __importDefault(require("@cucumber/cucumber/lib/runtime/attachment_manager/index"));
+const step_runner_1 = __importDefault(require("@cucumber/cucumber/lib/runtime/step_runner"));
+const messages = __importStar(require("@cucumber/messages"));
+const messages_1 = require("@cucumber/messages");
+const value_checker_1 = require("@cucumber/cucumber/lib/value_checker");
+const binding_registry_1 = require("./binding-registry");
+const console_1 = require("console");
+class TestCaseRunner {
+    attachmentManager;
+    currentTestCaseStartedId;
+    currentTestStepId;
+    eventBroadcaster;
+    stopwatch;
+    gherkinDocument;
+    newId;
+    pickle;
+    testCase;
+    maxAttempts;
+    skip;
+    filterStackTraces;
+    supportCodeLibrary;
+    testStepResults;
+    world;
+    worldParameters;
+    bindingRegistry;
+    constructor({ eventBroadcaster, stopwatch, gherkinDocument, newId, pickle, testCase, retries = 0, skip, filterStackTraces, supportCodeLibrary, worldParameters }) {
+        this.attachmentManager = new index_1.default(({ data, media, fileName }) => {
+            if ((0, value_checker_1.doesNotHaveValue)(this.currentTestStepId)) {
+                throw new Error('Cannot attach when a step/hook is not running. Ensure your step/hook waits for the attach to finish.');
+            }
+            const attachment = {
+                attachment: {
+                    body: data,
+                    contentEncoding: media.encoding,
+                    mediaType: media.contentType,
+                    fileName,
+                    testCaseStartedId: this.currentTestCaseStartedId,
+                    testStepId: this.currentTestStepId
+                }
+            };
+            this.eventBroadcaster.emit('envelope', attachment);
+        });
+        this.eventBroadcaster = eventBroadcaster;
+        this.stopwatch = stopwatch;
+        this.gherkinDocument = gherkinDocument;
+        this.maxAttempts = 1 + (skip ? 0 : retries);
+        this.newId = newId;
+        this.pickle = pickle;
+        this.testCase = testCase;
+        this.skip = skip;
+        this.filterStackTraces = filterStackTraces;
+        this.supportCodeLibrary = supportCodeLibrary;
+        this.worldParameters = worldParameters;
+        this.resetTestProgressData();
+        this.bindingRegistry = binding_registry_1.BindingRegistry.instance;
+    }
+    resetTestProgressData() {
+        this.world = new this.supportCodeLibrary.World({
+            attach: this.attachmentManager.create.bind(this.attachmentManager),
+            log: this.attachmentManager.log.bind(this.attachmentManager),
+            parameters: this.worldParameters
+        });
+        this.testStepResults = [];
+    }
+    getBeforeStepHookDefinitions() {
+        return this.supportCodeLibrary.beforeTestStepHookDefinitions.filter(hookDefinition => hookDefinition.appliesToTestCase(this.pickle));
+    }
+    getAfterStepHookDefinitions() {
+        return this.supportCodeLibrary.afterTestStepHookDefinitions
+            .slice(0)
+            .reverse()
+            .filter(hookDefinition => hookDefinition.appliesToTestCase(this.pickle));
+    }
+    getWorstStepResult() {
+        if (!this.testStepResults || this.testStepResults.length === 0) {
+            return {
+                status: this.skip ? messages.TestStepResultStatus.SKIPPED : messages.TestStepResultStatus.PASSED,
+                duration: messages.TimeConversion.millisecondsToDuration(0)
+            };
+        }
+        return (0, messages_1.getWorstTestStepResult)(this.testStepResults);
+    }
+    async invokeStep(stepParam, stepDefinition, hookParameter) {
+        const step = stepParam;
+        return await step_runner_1.default.run({
+            defaultTimeout: this.supportCodeLibrary.defaultTimeout,
+            filterStackTraces: this.filterStackTraces,
+            hookParameter,
+            step,
+            stepDefinition,
+            world: this.world
+        });
+    }
+    isSkippingSteps() {
+        return this.getWorstStepResult().status !== messages.TestStepResultStatus.PASSED;
+    }
+    shouldSkipHook(isBeforeHook) {
+        return this.skip || (this.isSkippingSteps() && isBeforeHook);
+    }
+    async aroundTestStep(testStepId, runStepFn) {
+        const testStepStarted = {
+            testStepStarted: {
+                testCaseStartedId: this.currentTestCaseStartedId,
+                testStepId,
+                timestamp: this.stopwatch.timestamp()
+            }
+        };
+        this.eventBroadcaster.emit('envelope', testStepStarted);
+        this.currentTestStepId = testStepId;
+        const testStepResult = await runStepFn();
+        this.currentTestStepId = undefined;
+        this.testStepResults?.push(testStepResult);
+        const testStepFinished = {
+            testStepFinished: {
+                testCaseStartedId: this.currentTestCaseStartedId,
+                testStepId,
+                testStepResult,
+                timestamp: this.stopwatch.timestamp()
+            }
+        };
+        this.eventBroadcaster.emit('envelope', testStepFinished);
+    }
+    async run() {
+        for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
+            const moreAttemptsRemaining = attempt + 1 < this.maxAttempts;
+            const willBeRetried = await this.runAttempt(attempt, moreAttemptsRemaining);
+            if (!willBeRetried) {
+                break;
+            }
+            this.resetTestProgressData();
+        }
+        return this.getWorstStepResult().status;
+    }
+    async runAttempt(attempt, moreAttemptsRemaining) {
+        this.currentTestCaseStartedId = this.newId();
+        const testCaseStarted = {
+            testCaseStarted: {
+                attempt,
+                testCaseId: this.testCase.id,
+                id: this.currentTestCaseStartedId,
+                timestamp: this.stopwatch.timestamp()
+            }
+        };
+        this.eventBroadcaster.emit('envelope', testCaseStarted);
+        // used to determine whether a hook is a Before or After
+        let didWeRunStepsYet = false;
+        for (const testStep of this.testCase.testSteps) {
+            await this.aroundTestStep(testStep.id, async () => {
+                if ((0, value_checker_1.doesHaveValue)(testStep.hookId)) {
+                    const hookParameter = {
+                        gherkinDocument: this.gherkinDocument,
+                        pickle: this.pickle,
+                        testCaseStartedId: this.currentTestCaseStartedId
+                    };
+                    if (didWeRunStepsYet) {
+                        hookParameter.result = this.getWorstStepResult();
+                        hookParameter.willBeRetried =
+                            this.getWorstStepResult().status === messages.TestStepResultStatus.FAILED && moreAttemptsRemaining;
+                    }
+                    return await this.runHook(findHookDefinition(testStep.hookId, this.supportCodeLibrary), hookParameter, !didWeRunStepsYet);
+                }
+                else {
+                    const pickleStep = this.pickle.steps.find(pickleStep => pickleStep.id === testStep.pickleStepId);
+                    const testStepResult = await this.runStep(pickleStep, testStep);
+                    didWeRunStepsYet = true;
+                    return testStepResult;
+                }
+            });
+        }
+        // End test case will call dispose on all context types
+        // passed into a binding and then end the context.
+        await global.messageCollector.endTestCase(this.currentTestCaseStartedId);
+        const willBeRetried = this.getWorstStepResult().status === messages.TestStepResultStatus.FAILED && moreAttemptsRemaining;
+        const testCaseFinished = {
+            testCaseFinished: {
+                testCaseStartedId: this.currentTestCaseStartedId,
+                timestamp: this.stopwatch.timestamp(),
+                willBeRetried
+            }
+        };
+        this.eventBroadcaster.emit('envelope', testCaseFinished);
+        return willBeRetried;
+    }
+    async runHook(hookDefinition, hookParameter, isBeforeHook) {
+        if (this.shouldSkipHook(isBeforeHook)) {
+            return {
+                status: messages.TestStepResultStatus.SKIPPED,
+                duration: messages.TimeConversion.millisecondsToDuration(0)
+            };
+        }
+        // Get the step binding and scenario context so that we can
+        // initialize any context objects before hooks are executed
+        const stepBinding = this.bindingRegistry.getStepBindingByCucumberKey(hookDefinition.options.cucumberKey);
+        if (!stepBinding)
+            throw (0, console_1.error)('Unable to find StepBinding!');
+        const scenarioContext = global.messageCollector.getHookScenarioContext(hookParameter);
+        if (!scenarioContext)
+            throw (0, console_1.error)('Unable to find the ManagedScenarioContext!');
+        await this.initializeContext(stepBinding, scenarioContext);
+        return await this.invokeStep(null, hookDefinition, hookParameter);
+    }
+    async runStepHooks(stepHooks, pickleStep, stepResult) {
+        const stepHooksResult = [];
+        const hookParameter = {
+            gherkinDocument: this.gherkinDocument,
+            pickle: this.pickle,
+            pickleStep,
+            testCaseStartedId: this.currentTestCaseStartedId,
+            testStepId: this.currentTestStepId,
+            result: stepResult
+        };
+        for (const stepHookDefinition of stepHooks) {
+            stepHooksResult.push(await this.invokeStep(null, stepHookDefinition, hookParameter));
+        }
+        return stepHooksResult;
+    }
+    async runStep(pickleStep, testStep) {
+        const stepDefinitions = testStep.stepDefinitionIds?.map(stepDefinitionId => {
+            return findStepDefinition(stepDefinitionId, this.supportCodeLibrary);
+        });
+        if (!stepDefinitions || stepDefinitions.length === 0) {
+            return {
+                status: messages.TestStepResultStatus.UNDEFINED,
+                duration: messages.TimeConversion.millisecondsToDuration(0)
+            };
+        }
+        else if (stepDefinitions.length > 1) {
+            return {
+                message: (0, helpers_1.getAmbiguousStepException)(stepDefinitions),
+                status: messages.TestStepResultStatus.AMBIGUOUS,
+                duration: messages.TimeConversion.millisecondsToDuration(0)
+            };
+        }
+        else if (this.isSkippingSteps()) {
+            return {
+                status: messages.TestStepResultStatus.SKIPPED,
+                duration: messages.TimeConversion.millisecondsToDuration(0)
+            };
+        }
+        // Get the step binding and scenario context so that we can
+        // initialize any context objects before hooks are executed
+        const stepBinding = this.bindingRegistry.getStepBindingByCucumberKey(stepDefinitions[0].options.cucumberKey);
+        if (!stepBinding)
+            throw (0, console_1.error)('Unable to find StepBinding!');
+        const scenarioContext = global.messageCollector.getStepScenarioContext(stepBinding);
+        if (!scenarioContext)
+            throw (0, console_1.error)('Unable to find the ManagedScenarioContext!');
+        await this.initializeContext(stepBinding, scenarioContext);
+        // next execute any before step hooks followed by the step if there are no
+        // failures in before step hooks.
+        let stepResult;
+        let stepResults = await this.runStepHooks(this.getBeforeStepHookDefinitions(), pickleStep);
+        if ((0, messages_1.getWorstTestStepResult)(stepResults).status !== messages.TestStepResultStatus.FAILED) {
+            stepResult = await this.invokeStep(pickleStep, stepDefinitions[0]);
+            stepResults.push(stepResult);
+        }
+        // run the after step hooks
+        const afterStepHookResults = await this.runStepHooks(this.getAfterStepHookDefinitions(), pickleStep, stepResult);
+        stepResults = stepResults.concat(afterStepHookResults);
+        const finalStepResult = (0, messages_1.getWorstTestStepResult)(stepResults);
+        let finalDuration = messages.TimeConversion.millisecondsToDuration(0);
+        for (const result of stepResults) {
+            finalDuration = messages.TimeConversion.addDurations(finalDuration, result.duration);
+        }
+        finalStepResult.duration = finalDuration;
+        return finalStepResult;
+    }
+    /**
+     * Helper used to initialize any context types that are passed into
+     * a binding class before any hooks or steps are executed.
+     * @param stepBinding
+     * @param scenarioContext
+     */
+    async initializeContext(stepBinding, scenarioContext) {
+        const contextTypes = this.bindingRegistry.getContextTypesForTarget(stepBinding.targetPrototype);
+        if (contextTypes.length > 0) {
+            scenarioContext.getOrActivateBindingClass(stepBinding.targetPrototype, contextTypes, this.world);
+            await scenarioContext.initialize();
+        }
+    }
+}
+exports.default = TestCaseRunner;
+function findHookDefinition(id, supportCodeLibrary) {
+    return [...supportCodeLibrary.beforeTestCaseHookDefinitions, ...supportCodeLibrary.afterTestCaseHookDefinitions].find(definition => definition.id === id);
+}
+function findStepDefinition(id, supportCodeLibrary) {
+    return supportCodeLibrary.stepDefinitions.find(definition => definition.id === id);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-case-runner.js","sourceRoot":"","sources":["../../src/cucumber/test-case-runner.ts"],"names":[],"mappings":"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"}

package/lib/types/types.d.ts

@@ -1,3 +1,4 @@
+import { World } from '@cucumber/cucumber';
 /**
  * A string representation of a [[RegExp]] that defines a Cucumber step pattern.
  */
@@ -14,7 +15,7 @@ export interface ContextType {
     /**
      * A default constructor.
      */
-    new (): any;
+    new (worldObj: World): any;
 }
 export type TypeDecorator = <T>(target: {
     new (...args: any[]): T;

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.3.0";
+export declare const version = "6.5.0";

package/lib/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // Generated by genversion.
-exports.version = '6.3.0';
+exports.version = '6.5.0';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJCQUEyQjtBQUNkLFFBQUEsT0FBTyxHQUFHLE9BQU8sQ0FBQSJ9

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@lynxwall/cucumber-tsflow",
-	"description": "Provides 'specflow' like bindings for CucumberJS 9.1.0+ in TypeScript 4.0+.",
-	"version": "6.3.0",
+	"description": "Provides 'specflow' like bindings for CucumberJS 9.6.0+ in TypeScript 5.0+.",
+	"version": "6.5.0",
 	"author": "Lonnie Wall <lynxdev@lynxwall.com>",
 	"license": "MIT",
 	"main": "./lib/index",