@lynxwall/cucumber-tsflow 6.4.0 → 6.5.0

package/README.md

@@ -538,34 +538,89 @@ Like 'specflow', cucumber-tsflow supports a simple dependency injection framewor
 
 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.
 
-**New in version 6.4.0:**
+**Recent Updates:**
 
-- 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).
+- 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.
 
-**To use context injection:**
+- 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.
 
-  ```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 = '';
-  	}
-  }
-  ```
+**Synchronous example:**
 
-- 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.
+```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';
@@ -589,6 +644,36 @@ export default class InjectionTestSteps1 {
 }
 ```
 
+**Multiple Context classes example:**
+
+```typescript
+import { binding, given, when } from '@lynxwall/cucumber-tsflow';
+import { ScenarioContext } from '../fixtures/scenario-context';
+import { SyncContext } from '../fixtures/sync-context';
+import { expect } from 'chai';
+
+@binding([ScenarioContext, SyncContext])
+export default class InjectionTestSteps1 {
+	constructor(private context: ScenarioContext, private syncContext: SyncContext) {}
+
+	@given('The Workspace is available and valid')
+	theWorkspaceIsAvailableAndValid() {
+		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.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 the following:

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

@@ -15,8 +15,37 @@ export declare class ManagedScenarioContext implements ScenarioContext {
      */
     get scenarioInfo(): ScenarioInfo;
     getOrActivateBindingClass(targetPrototype: any, contextTypes: ContextType[], worldObj: World): any;
-    dispose(): void;
+    /**
+     * 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.
@@ -42,12 +51,30 @@ class ManagedScenarioContext {
             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, worldObj) {
         const invokeBindingConstructor = (args) => {
@@ -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, (worldObj) => {
+        const contextObjects = underscore_1.default.map(contextTypes, contextType => this.getOrActivateContext(contextType.prototype, (worldObj) => {
             return new contextType(worldObj);
         }, worldObj));
         return invokeBindingConstructor(contextObjects);
     }
+    /**
+     * 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);
+        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(optional);
-        this._activeObjects.set(targetPrototype, activeObject);
+        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

@@ -66,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

@@ -122,7 +122,6 @@ class MessageCollector {
         }
         else if (envelope.testCaseFinished) {
             this.storeTestCaseResult(envelope.testCaseFinished);
-            this.endTestCase(envelope.testCaseFinished);
         }
     }
     initTestCaseAttempt(testCaseStarted) {
@@ -223,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;
             }
         }
@@ -256,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,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

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/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.4.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.4.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.4.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",