@alator21/jobless-machine@0.0.20

Base class for value wrappers that hold simple, static values. Provides a common implementation for storing and accessing wrapped values.

A copy strategy that copies all step outputs to the context with a prefix. This is the most common copy strategy, automatically adding a namespace to outputs.

Base class for all assertions in the test framework.

Factory for creating multiple assertion instances from a template. Useful for repeating assertions or generating dynamic assertion collections.

A copy strategy that combines multiple copy strategies. Executes each strategy in sequence, allowing complex copy patterns.

Type-safe key-value store for sharing data between test steps. Stores value wrappers which can be resolved later during test execution.

An assertion that compares two value wrappers for equality or inequality. Uses strict equality (===) for comparison.

Type-safe context schema that provides utilities for creating runners, value wrappers, and copy strategies with full TypeScript type inference.

A value wrapper that references a value stored in the test context. The actual value is resolved at extraction time using VExtractor.

Base class for copy strategies that control how step outputs are copied to context. Provides filtering and key mapping functionality for data transfer.

Create a typed context schema using type-only parameters This is the preferred way to create typed schemas as it provides:

Placeholder value wrapper that holds undefined. Used as a default or temporary value in scenarios where a real value isn't available yet.

Type helper to get the type of a property at a given path in an object. Handles both object properties and array indices.

Interface that adds fluent .get() method to ValueWrappers. This is provided as a separate interface to avoid variance issues with the base ValueWrapper class.

An assertion that validates HTTP responses stored in the context. Checks whether an HTTP request succeeded (2xx status) or failed (non-2xx status).

Validates HTTP error responses with expected status codes and exception messages. Used to verify that API endpoints return proper error responses.

Type definition for HTTP response and error fields stored in context. Used to standardize HTTP-related data structures across the framework.

Base class for HTTP request steps. Provides common functionality for making HTTP calls and storing responses/errors.

Makes a ValueWrapper "gettable" by adding a fluent .get() method via Proxy. This allows for chainable nested property access without modifying the base ValueWrapper class.

A value wrapper that extracts a nested property from another value wrapper. This enables accessing nested values in a type-safe, deferred way.

Create a schema with a helper for defining common field types This reduces repetition when defining similar prefixed contexts

A step that prints a message to the console. Useful for debugging and logging during test execution.

Main test orchestrator that executes steps and assertions sequentially. Provides a fluent API for building complex test scenarios with type-safe context management.

A copy strategy that maps specific fields from step outputs to context keys. Can either use explicit mappings or copy all fields as-is.

A value wrapper that holds a static value. The value is provided at construction time and never changes.

Base class for all executable steps in the test framework.

Factory for creating multiple step instances from a template. Useful for repeating steps or generating dynamic step collections.

Manages the execution order of steps and assertions in a test scenario. Timeline maintains an ordered collection of steps, assertions, and their factories.

Base class for all value wrappers in the framework. Value wrappers provide a flexible abstraction for representing values that may be static, context-referenced, or computed. They enable deferred value resolution and type-safe value handling.

Utility class for formatting values in a human-readable way. Handles deep printing of objects, arrays, and other complex types.

Extracts actual values from value wrappers.

A step that pauses execution for a specified duration. Useful for waiting for async operations, delays between API calls, or simulating timing scenarios.