@autometa/executor 1.0.0-rc.0

package/dist/scope-lifecycle.d.ts

@@ -0,0 +1,138 @@
+import type { HookType, ParameterRegistryLike, ScopeExecutionAdapter, ScopeKind, ScopeNode, StepDefinition } from "@autometa/scopes";
+import type { SimpleStep } from "@autometa/gherkin";
+import type { SimplePickle } from "@autometa/gherkin";
+import type { ScenarioExecution } from "@autometa/test-builder";
+import { type HookCollection, type ResolvedHook } from "./hooks";
+import type { ExecutorRuntime } from "./types";
+export type StepStatus = "passed" | "failed" | "skipped";
+export interface HookLifecycleTargetScopeMetadata {
+    readonly id: string;
+    readonly kind: ScopeKind;
+    readonly name?: string;
+}
+type ScenarioLifecycleType = ScenarioExecution<unknown>["type"];
+export interface HookLifecycleScenarioMetadata {
+    readonly id: string;
+    readonly name: string;
+    readonly type: ScenarioLifecycleType;
+    readonly tags: readonly string[];
+    readonly qualifiedName: string;
+}
+export interface HookLifecycleStepMetadata {
+    readonly index: number;
+    readonly keyword?: string;
+    readonly text?: string;
+    readonly status?: StepStatus;
+}
+export interface HookLifecycleMetadata {
+    readonly targetScope: HookLifecycleTargetScopeMetadata;
+    readonly scenario?: HookLifecycleScenarioMetadata;
+    readonly step?: HookLifecycleStepMetadata;
+    readonly hook?: unknown;
+    readonly [key: string]: unknown;
+}
+export interface StepHookDetails<World> {
+    readonly index: number;
+    readonly definition?: StepDefinition<World>;
+    readonly gherkin?: SimpleStep;
+    readonly status?: StepStatus;
+}
+export interface StepHookInvocationOptions<World> {
+    readonly direction?: HookDirection;
+    readonly step?: StepHookDetails<World>;
+    readonly metadata?: Record<string, unknown>;
+}
+export type HookInvoker<World> = (hooks: readonly ResolvedHook<World>[], options: StepHookInvocationOptions<World>) => Promise<void>;
+export interface HookLogPathSegment {
+    readonly id: string;
+    readonly kind: ScopeKind | "step";
+    readonly name: string;
+    readonly keyword?: string;
+}
+export interface HookLogStepDetails {
+    readonly index: number;
+    readonly keyword?: string;
+    readonly text?: string;
+    readonly status?: StepStatus;
+}
+export interface HookLogScenarioDetails {
+    readonly id: string;
+    readonly name: string;
+    readonly fullName: string;
+    readonly keyword?: string;
+    readonly language?: string;
+}
+export type HookLogPhase = "before" | "after";
+export interface HookLogEvent {
+    readonly message: string;
+    readonly hookId: string;
+    readonly hookType: HookType;
+    readonly hookDescription?: string;
+    readonly phase: HookLogPhase;
+    readonly path: readonly HookLogPathSegment[];
+    readonly scenario?: HookLogScenarioDetails;
+    readonly step?: HookLogStepDetails;
+    readonly targetKeyword?: string;
+    readonly language?: string;
+}
+export type HookLogListener = (event: HookLogEvent) => void;
+export interface ScopeLifecycleOptions {
+    readonly hookLogger?: HookLogListener;
+    readonly featureLanguage?: string;
+    readonly scopeKeywords?: ReadonlyMap<string, string>;
+}
+export interface ScenarioEventContext {
+    readonly pickle: SimplePickle;
+}
+export interface ScenarioRunContext<World> {
+    readonly world: World;
+    readonly parameterRegistry: ParameterRegistryLike | undefined;
+    readonly beforeStepHooks: readonly ResolvedHook<World>[];
+    readonly afterStepHooks: readonly ResolvedHook<World>[];
+    readonly events?: ScenarioEventContext;
+    invokeHooks: HookInvoker<World>;
+}
+type HookDirection = "asc" | "desc";
+export declare class ScopeLifecycle<World> {
+    private readonly adapter;
+    private readonly states;
+    private readonly depthMap;
+    private readonly root;
+    private readonly hookLogger?;
+    private readonly featureLanguage;
+    private readonly scopeKeywords;
+    constructor(adapter: ScopeExecutionAdapter<World>, options?: ScopeLifecycleOptions);
+    configurePersistentScope(scope: ScopeNode<World>, runtime: ExecutorRuntime): void;
+    collectScenarioHooks(execution: ScenarioExecution<World>): HookCollection<World>;
+    runScenario(execution: ScenarioExecution<World>, hooks: HookCollection<World>, runner: (world: World, context: ScenarioRunContext<World>) => Promise<void>, options?: {
+        readonly events?: ScenarioEventContext;
+    }): Promise<void>;
+    private ensureState;
+    private teardownState;
+    private ensureAncestorStates;
+    private resolveParentWorld;
+    private resolveParentWorldForScenario;
+    private getParentScope;
+    private isPersistentScope;
+    private shouldMaterializePersistentScope;
+    private runScopeHooks;
+    private createHookInvoker;
+    private invokeHooks;
+    private buildHookMetadata;
+    private collectHooksForScope;
+    private buildChain;
+    private createContextLogger;
+    private buildHookLogEvent;
+    private toPathSegment;
+    private toStepSegment;
+    private toStepDetails;
+    private describeStep;
+    private describeStepExpression;
+    private findScenarioSegmentIndex;
+    private buildScenarioDetails;
+    private resolveLanguage;
+    private sortHooks;
+    private compareHooks;
+    private buildDepthMap;
+}
+export {};

package/dist/tag-filter.d.ts

@@ -0,0 +1,4 @@
+export interface TagFilter {
+    evaluate(tags: readonly string[]): boolean;
+}
+export declare const createTagFilter: (expression: string | undefined) => TagFilter;

package/dist/timeouts.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig } from "@autometa/config";
+import type { TimeoutSpec } from "@autometa/scopes";
+export type TimeoutSource = "scenario" | "hook" | "config" | "default";
+export interface TimeoutResolution {
+    milliseconds: number | undefined;
+    source: TimeoutSource;
+}
+export declare const resolveTimeout: (explicit: TimeoutSpec | undefined, config: ExecutorConfig, explicitSource?: TimeoutSource) => TimeoutResolution;
+export declare const chooseTimeout: (primary: TimeoutSpec | undefined, secondary: TimeoutSpec | undefined, config: ExecutorConfig) => TimeoutResolution;

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+export type HookHandler = () => void | Promise<void>;
+export type SuiteFn = {
+    (title: string, handler: () => void, timeout?: number): void;
+    skip: SuiteFn;
+    only: SuiteFn;
+    concurrent?: SuiteFn;
+    sequential?: SuiteFn;
+};
+export type TestFn = {
+    (title: string, handler: () => void | Promise<void>, timeout?: number): void;
+    skip: TestFn;
+    only: TestFn;
+    concurrent?: TestFn;
+    sequential?: TestFn;
+    failing?: TestFn;
+    fails?: TestFn;
+    todo?: (title: string, reason?: string) => void;
+    pending?: (title: string, reason?: string) => void;
+};
+export interface ExecutorRuntime {
+    suite: SuiteFn;
+    test: TestFn;
+    beforeAll(handler: HookHandler, timeout?: number): void;
+    afterAll(handler: HookHandler, timeout?: number): void;
+    beforeEach(handler: HookHandler, timeout?: number): void;
+    afterEach(handler: HookHandler, timeout?: number): void;
+    currentTestName(): string | undefined;
+    retry?(count: number): void;
+    warn?(message: string): void;
+    logError?(error: Error): void;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@autometa/executor",
+  "version": "1.0.0-rc.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs",
+    "default": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "dependencies": {
+    "@cucumber/cucumber-expressions": "^16.1.2",
+    "@cucumber/tag-expressions": "^5.0.1",
+    "@autometa/events": "1.0.0-rc.0",
+    "@autometa/gherkin": "1.0.0-rc.0",
+    "@autometa/errors": "1.0.0-rc.0",
+    "@autometa/config": "1.0.0-rc.0",
+    "@autometa/scopes": "1.0.0-rc.0",
+    "@autometa/test-builder": "1.0.0-rc.0"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.54.1",
+    "@typescript-eslint/parser": "^5.54.1",
+    "eslint": "^8.37.0",
+    "eslint-config-prettier": "^8.3.0",
+    "rimraf": "^4.1.2",
+    "tsup": "^7.2.0",
+    "typescript": "^4.9.5",
+    "vitest": "1.4.0",
+    "eslint-config-custom": "0.6.0",
+    "tsconfig": "0.7.0",
+    "tsup-config": "0.1.0"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit -p tsconfig.dev.json",
+    "type-check:watch": "tsc --noEmit --watch -p tsconfig.dev.json",
+    "build": "tsup && pnpm run build:types",
+    "build:types": "rimraf tsconfig.types.tsbuildinfo && tsc --build tsconfig.types.json",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest --passWithNoTests",
+    "test:ui": "vitest --ui --passWithNoTests",
+    "coverage": "vitest run --coverage --passWithNoTests",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "prettify": "prettier --config .prettierrc 'src/**/*.ts' --write",
+    "clean": "rimraf dist"
+  }
+}