cucumber-fixture 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lennart Gerken
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# cucumber-fixture
+
+`cucumber-fixture` provides a fixture structure for Cucumber step definitions.
+
+## Installation
+
+```sh
+npm i -D cucumber-fixture
+```
+
+## Usage
+
+To use `cucumber-fixture`, call `createKeywords`, pass the original Cucumber keywords, and define the fixtures you need.
+
+For every fixture, define a `setup` function that specifies how the fixture is created. You can also optionally define a `teardown` function. `teardown` functions are called automatically after each test.
+
+A fixture can also be marked as `global` to keep it alive for the whole test run. In that case, its `teardown` is run automatically after the run.
+
+An example would be to define fixtures for E2E tests:
+
+```ts
+import { createKeywords } from 'cucumber-fixture'
+import {
+    BeforeAll as baseBeforeAll,
+    AfterAll as baseAfterAll,
+    Before as baseBefore,
+    After as baseAfter,
+    defineStep
+} from '@cucumber/cucumber'
+import { Browser, BrowserContext, chromium, Page } from 'playwright'
+import { CustomWorld, world } from '@/features/support/world'
+import { SomePageObject } from '@/pages/some-page-object'
+
+export const { BeforeAll, AfterAll, Before, After, Given, When, Then } =
+    createKeywords<{
+        world: CustomWorld
+        browser: Browser
+        context: BrowserContext
+        page: Page
+        somePageObject: SomePageObject
+    }>(baseBeforeAll, baseAfterAll, baseBefore, baseAfter, defineStep, {
+        world: () => world,
+        browser: {
+            setup: () => chromium.launch(),
+            teardown: ({ browser }) => browser.close(),
+            global: true
+        },
+        context: {
+            setup: ({ browser }) => browser.newContext(),
+            teardown: ({ context }) => context.close()
+        },
+        page: ({ context }) => context.newPage(),
+        somePageObject: ({ page }) => {
+            // Initialize the page object.
+            // ...
+            return new SomePageObject(page)
+        }
+    })
+```
+
+You can now use your fixtures directly in your step definitions:
+
+```ts
+import { Given } from '@/keywords'
+
+Given(
+    'some Given step with a parameter {string}',
+    async ({ somePageObject }, someData: string) => {
+        // Use the fixtures in your step definitions.
+        await somePageObject.doSomething(someData)
+    }
+)
+```
+
+## License
+
+This package is licensed under the [MIT License](./LICENSE).

package/dist/index.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var pseudoFixture = require('pseudo-fixture');
+
+function createKeywords(baseBeforeAll, baseAfterAll, baseBefore, baseAfter, defineStep, fixtureDefinitions) {
+    const pseudoFixture$1 = new pseudoFixture.PseudoFixture(fixtureDefinitions);
+    baseAfter(() => pseudoFixture$1.runTeardown());
+    baseAfterAll(() => pseudoFixture$1.runGlobalTeardown());
+    function createCallback(code) {
+        const callback = (...args) => {
+            return pseudoFixture$1.run(code, ...args);
+        };
+        const originalLength = code.length;
+        Object.defineProperty(callback, 'length', {
+            value: originalLength > 0 ? code.length - 1 : 0
+        });
+        return callback;
+    }
+    function createHook(baseHook) {
+        return function (optionsOrCode, code) {
+            if (typeof optionsOrCode === 'function')
+                baseHook(createCallback(optionsOrCode));
+            else
+                baseHook(optionsOrCode, createCallback(code));
+        };
+    }
+    function createGlobalHook(baseGlobalHook) {
+        return function (optionsOrCode, code) {
+            if (typeof optionsOrCode === 'function')
+                baseGlobalHook(createCallback(optionsOrCode));
+            else
+                baseGlobalHook(optionsOrCode, createCallback(code));
+        };
+    }
+    const fixDefineStep = function (pattern, optionsOrCode, code) {
+        if (typeof optionsOrCode === 'function')
+            defineStep(pattern, createCallback(optionsOrCode));
+        else
+            defineStep(pattern, optionsOrCode, createCallback(code));
+    };
+    return {
+        BeforeAll: createGlobalHook(baseBeforeAll),
+        AfterAll: createGlobalHook(baseAfterAll),
+        Before: createHook(baseBefore),
+        After: createHook(baseAfter),
+        Given: fixDefineStep,
+        When: fixDefineStep,
+        Then: fixDefineStep
+    };
+}
+
+exports.createKeywords = createKeywords;

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import type { BeforeAll as OriginalBeforeAll, Before as OriginalBefore, defineStep as OriginalStep } from '@cucumber/cucumber';
+import { Definitions } from 'pseudo-fixture';
+type BaseGlobalHook = typeof OriginalBeforeAll;
+type BaseHook = typeof OriginalBefore;
+type BaseStep = typeof OriginalStep;
+type Code<F, A extends unknown[]> = (fixtures: F, ...args: A) => Promise<void> | void;
+type HookCode<F> = (fixtures: F, options: Parameters<Parameters<BaseHook>[1]>[0]) => Promise<void> | void;
+type GlobalHookCode<F> = (fixtures: F) => Promise<void> | void;
+type Step<F> = {
+    <A extends unknown[]>(pattern: string | RegExp, options: Parameters<BaseStep>[1], code: Code<F, A>): void;
+    <A extends unknown[]>(pattern: string | RegExp, code: Code<F, A>): void;
+};
+type Hook<F> = {
+    (options: Parameters<BaseHook>[0], code: HookCode<F>): void;
+    (code: HookCode<F>): void;
+};
+type GlobalHook<F> = {
+    (options: Parameters<BaseGlobalHook>[0], code: GlobalHookCode<F>): void;
+    (code: GlobalHookCode<F>): void;
+};
+export declare function createKeywords<F extends object>(baseBeforeAll: BaseGlobalHook, baseAfterAll: BaseGlobalHook, baseBefore: BaseHook, baseAfter: BaseHook, defineStep: BaseStep, fixtureDefinitions: Definitions<F, object>): {
+    BeforeAll: GlobalHook<F>;
+    AfterAll: GlobalHook<F>;
+    Before: Hook<F>;
+    After: Hook<F>;
+    Given: Step<F>;
+    When: Step<F>;
+    Then: Step<F>;
+};
+export {};

package/dist/index.js

@@ -0,0 +1,50 @@
+import { PseudoFixture } from 'pseudo-fixture';
+
+function createKeywords(baseBeforeAll, baseAfterAll, baseBefore, baseAfter, defineStep, fixtureDefinitions) {
+    const pseudoFixture = new PseudoFixture(fixtureDefinitions);
+    baseAfter(() => pseudoFixture.runTeardown());
+    baseAfterAll(() => pseudoFixture.runGlobalTeardown());
+    function createCallback(code) {
+        const callback = (...args) => {
+            return pseudoFixture.run(code, ...args);
+        };
+        const originalLength = code.length;
+        Object.defineProperty(callback, 'length', {
+            value: originalLength > 0 ? code.length - 1 : 0
+        });
+        return callback;
+    }
+    function createHook(baseHook) {
+        return function (optionsOrCode, code) {
+            if (typeof optionsOrCode === 'function')
+                baseHook(createCallback(optionsOrCode));
+            else
+                baseHook(optionsOrCode, createCallback(code));
+        };
+    }
+    function createGlobalHook(baseGlobalHook) {
+        return function (optionsOrCode, code) {
+            if (typeof optionsOrCode === 'function')
+                baseGlobalHook(createCallback(optionsOrCode));
+            else
+                baseGlobalHook(optionsOrCode, createCallback(code));
+        };
+    }
+    const fixDefineStep = function (pattern, optionsOrCode, code) {
+        if (typeof optionsOrCode === 'function')
+            defineStep(pattern, createCallback(optionsOrCode));
+        else
+            defineStep(pattern, optionsOrCode, createCallback(code));
+    };
+    return {
+        BeforeAll: createGlobalHook(baseBeforeAll),
+        AfterAll: createGlobalHook(baseAfterAll),
+        Before: createHook(baseBefore),
+        After: createHook(baseAfter),
+        Given: fixDefineStep,
+        When: fixDefineStep,
+        Then: fixDefineStep
+    };
+}
+
+export { createKeywords };

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "cucumber-fixture",
+    "version": "0.1.0",
+    "license": "MIT",
+    "author": "Lennart Gerken",
+    "description": "cucumber-fixture provides a fixture structure for Cucumber step definitions.",
+    "keywords": [
+        "cucumber",
+        "bdd",
+        "test",
+        "testautomation",
+        "fixtures"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/lennartgerken/cucumber-fixture.git"
+    },
+    "bugs": {
+        "url": "https://github.com/lennartgerken/cucumber-fixture/issues"
+    },
+    "type": "module",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "module": "./dist/index.js",
+    "main": "./dist/index.cjs",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "pretty": "prettier . --write",
+        "pretty:check": "prettier . --check",
+        "lint": "eslint .",
+        "type-check": "tsc -p tsconfig.json --noEmit",
+        "type-check:tests": "tsc -p tests/tsconfig.json --noEmit",
+        "build": "rollup -c",
+        "test": "vitest run"
+    },
+    "peerDependencies": {
+        "@cucumber/cucumber": "^13.0.0"
+    },
+    "dependencies": {
+        "pseudo-fixture": "^1.4.0"
+    },
+    "devDependencies": {
+        "@cucumber/cucumber": "^13.0.0",
+        "@eslint/js": "^10.0.1",
+        "@rollup/plugin-typescript": "^12.3.0",
+        "@types/node": "^25.9.3",
+        "eslint": "^10.4.1",
+        "prettier": "^3.8.4",
+        "rollup": "^4.61.1",
+        "tslib": "^2.8.1",
+        "tsx": "^4.22.4",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.60.1",
+        "vitest": "^4.1.8"
+    }
+}