bluestone-commercetools testing

The helpers this package ships for your tests, by the path you import them from. How the test layers fit together is in the testing guide.

@evolve-framework/bluestone-commercetools/testing

Fixtures for Bluestone and commercetools data, and an MSW server with the mocked commercetools project

CloseEvent

import { CloseEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends Event

new CloseEvent(type: string, init?: CloseEventInit)

Option	Type	Description
code?	number
reason?	string
wasClean?	boolean

Disposable

import { Disposable } from "@evolve-framework/bluestone-commercetools/testing";

new Disposable()

Method	Description
dispose(): void

Emitter

import { Emitter } from "@evolve-framework/bluestone-commercetools/testing";

new Emitter()

FetchResponse

import { FetchResponse } from "@evolve-framework/bluestone-commercetools/testing";

Extends Response

new FetchResponse(body?: BodyInit | null, init?: FetchResponseInit)

Option	Type	Description
url?	string

GraphQLSubscriptionEventEmitted when a GraphQL subscription is established over an intercepted WebSocket connection (i.e.

import { GraphQLSubscriptionEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<void, void, "graphql:subscription">

new GraphQLSubscriptionEvent(init: GraphQLSubscriptionEventInit)

Option	Type	Description
operationName	string
query	string
variables	Record<string, unknown>
request	Request

HandlerThe base class for all the handlers.

import { Handler } from "@evolve-framework/bluestone-commercetools/testing";

new Handler()

Method	Description
reset(): void	Reset the runtime state this handler accumulated while handling the network (e.g.
restore(): void	Restore this handler so it can handle the network again after being exhausted (e.g.
dispose(): MaybePromise<void>	Release the resources held by this handler.

HandlersController

import { HandlersController } from "@evolve-framework/bluestone-commercetools/testing";

new HandlersController()

Method	Description
currentHandlers(): AnyHandler[]
listHandlers(): AnyHandler[]	Return the list of explicitly registered handlers.
getHandlersByKind<Kind>( kind: Kind, ): Array<HandlerOfKind<Kind>>	Return the list of handlers of the given kind.
use(nextHandlers: AnyHandler[]): void
reset(nextHandlers: AnyHandler[]): void
restore(): void
dispose(): MaybePromise<void>

HttpResponseA drop-in replacement for the standard Response class to allow additional features, like mocking the response Set-Cookie header.

import { HttpResponse } from "@evolve-framework/bluestone-commercetools/testing";

Extends FetchResponse

new HttpResponse(body?: TransparentNoInfer<BodyType> | null, init?: HttpResponseInit)

Option	Type	Description
type?	ResponseType

Interceptor

import { Interceptor } from "@evolve-framework/bluestone-commercetools/testing";

Extends Disposable

new Interceptor()

Method	Description
apply(owner?: object | undefined): void

NetworkFrameThe base for the network frames.

import { NetworkFrame } from "@evolve-framework/bluestone-commercetools/testing";

new NetworkFrame(protocol: Protocol, data: Data)

Method	Description
getHandlers(controller: HandlersController): AnyHandler[]
resolve( handlers: AnyHandler[], onUnhandledFrame: UnhandledFrameHandle, resolutionContext?: NetworkFrameResolutionContext, ): Promise<boolean | null>	Resolve the current frame against the given list of handlers.
passthrough(): void	Perform this network frame as-is.
errorWith(reason?: unknown): void	Error the underling network frame.
getUnhandledMessage(): Promise<string>	Get a message to be used when this frame is unhandled.

RequestEvent

import { RequestEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<DataType, ReturnType, EventType>

new RequestEvent(type: EventType, data: DataType)

RequestHandler

import { RequestHandler } from "@evolve-framework/bluestone-commercetools/testing";

Extends Handler

new RequestHandler(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>)

Option	Type	Description
info	HandlerInfo
resolver	ResponseResolver<any, DefaultBodyType, undefined>
options?	HandlerOptions

Method	Description
predicate( args: { request: Request; parsedResult: ParsedResult; resolutionContext?: ResponseResolutionContext | undefined; }, ): boolean | Promise<boolean>	Determine if the intercepted request should be mocked.
log( args: { request: Request; response: Response; parsedResult: ParsedResult; }, ): void	Print out the successfully handled request.
parse( _args: { request: Request; resolutionContext?: ResponseResolutionContext | undefined; }, ): Promise<ParsedResult>	Parse the intercepted request to extract additional information from it.
test( args: { request: Request; resolutionContext?: ResponseResolutionContext | undefined; }, ): Promise<boolean>	Test if this handler matches the given request.
run( args: { request: StrictRequest<any>; requestId: string; resolutionContext?: ResponseResolutionContext | undefined; }, ): Promise<RequestHandlerExecutionResult<ParsedResult> | null>	Execute this request handler and produce a mocked response using the given resolver function.

ResponseEvent

import { ResponseEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<DataType, ReturnType, EventType>

new ResponseEvent(type: EventType, data: DataType)

TypedEvent

import { TypedEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends MessageEvent<DataType>

new TypedEvent(args: [DataType] extends [void] ? [type: EventType] : [type: EventType, init: { data: DataType; }])

UnhandledExceptionEvent

import { UnhandledExceptionEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<DataType, ReturnType, EventType>

new UnhandledExceptionEvent(type: EventType, data: DataType)

WebSocketClientHandleThe handle to a WebSocket client connection: its identity and controls.

import { WebSocketClientHandle } from "@evolve-framework/bluestone-commercetools/testing";

Message is what crosses this connection: raw WebSocket data, or the messages of the extension applied to it.

new WebSocketClientHandle()

Method	Description
send(data: Message): void
close(code?: number | undefined, reason?: string | undefined): void
addEventListener<EventType>( type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: boolean | AddEventListenerOptions, ): void
removeEventListener<EventType>( event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: boolean | EventListenerOptions, ): void

WebSocketConnectionEvent

import { WebSocketConnectionEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<void, void, "connection">

new WebSocketConnectionEvent(connection: WebSocketHandlerConnection<Message>)

Option	Type	Description
client	WebSocketClientHandle<Message>
server	WebSocketServerHandle<Message>
info	WebSocketConnectionInfo
params	PathParams<string>

WebSocketConnectionEvent$1

import { WebSocketConnectionEvent$1 } from "@evolve-framework/bluestone-commercetools/testing";

Extends TypedEvent<DataType, ReturnType, EventType>

new WebSocketConnectionEvent$1(type: EventType, data: DataType)

WebSocketErrorEvent

import { WebSocketErrorEvent } from "@evolve-framework/bluestone-commercetools/testing";

Extends WebSocketConnectionEvent$1<DataType, ReturnType, EventType>

new WebSocketErrorEvent(type: EventType, data: DataType)

WebSocketExtensionA WebSocket extension: the server-side implementation of a protocol layered on top of WebSocket (e.g.

import { WebSocketExtension } from "@evolve-framework/bluestone-commercetools/testing";

The interceptor decides when each part applies: send() encodes, frames are decoded before being dispatched as message events, connect and receive frames are sent while the mocked connection plays the server, and the extension is exposed on the connection event.

An extension is invisible to the connection consumer: client.send(), server.send(), and the message events all operate on messages, and the session frames never surface. Raw frames forwarded between the client and the original server (passthrough) are never touched.

A method returns a single value for a one-to-one mapping, an iterator (e.g. a generator) to unfold one input into many, or nothing to drop the input.

new WebSocketExtension()

Method	Description
match	Whether this extension applies to the given connection.
encode( message: Message, context: WebSocketExtensionMessageContext<Message>, ): WebSocketExtensionResult<WebSocketData>	Encode the given message into the raw frame(s) to send to the peer.
decode( data: WebSocketData, context: WebSocketExtensionMessageContext<Message>, ): WebSocketExtensionResult<Message>	Decode the given raw frame into the message(s) to dispatch as message events.
connect	The raw frame(s) a server of this extension's protocol sends once the connection is established (e.g.
receive	The raw frame(s) a server of this extension's protocol sends back in response to the given client frame (e.g.
extend	The server API this extension adds to the given connection (e.g.
apply( connection: { client: WebSocketClientHandle<unknown>; server: WebSocketServerHandle<unknown>; }, ): void	Apply this extension to the given connection.

WebSocketHandler

import { WebSocketHandler } from "@evolve-framework/bluestone-commercetools/testing";

Extends Handler

new WebSocketHandler(url: Path, options?: WebSocketHandlerOptions)

Option	Type	Description
extensions?	readonly AnyWebSocketExtension[]	WebSocket extensions applied to every connection matched by this handler, left to right. The last one applied encodes and decodes the traffic, and every one of them extends the connection event with its own API.

Method	Description
parse( args: { url: string | URL; resolutionContext?: WebSocketResolutionContext | undefined; }, ): WebSocketHandlerParsedResult
predicate( args: { url: string | URL; parsedResult: WebSocketHandlerParsedResult; }, ): boolean
test( url: string | URL, resolutionContext?: (WebSocketResolutionContext & { strict?: boolean | undefined; }), ): boolean
run( connection: WebSocketConnectionEventData<WebSocketData>, resolutionContext?: WebSocketResolutionContext, ): Promise<WebSocketHandlerResolvedConnection<Extension> | null>
log( connection: WebSocketConnectionEventData<WebSocketData>, ): () => void

WebSocketServerHandleThe handle to the original WebSocket server connection: its controls.

import { WebSocketServerHandle } from "@evolve-framework/bluestone-commercetools/testing";

new WebSocketServerHandle()

Method	Description
connect(): void
send(data: Message): void
close(): void
addEventListener<EventType>( event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: boolean | AddEventListenerOptions, ): void
removeEventListener<EventType>( event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: boolean | EventListenerOptions, ): void

createCtProductFromBpProductBuild the commercetools product a sync would have made from a Bluestone product, to seed the commercetools mock before a test.

import { createCtProductFromBpProduct } from "@evolve-framework/bluestone-commercetools/testing";

function createCtProductFromBpProduct(
  bpProduct: Product,
  bpVariants: Product[],
  options?: CommercetoolsProductOptions,
): Product$1

Option	Type	Description
locale?	string	The locale of the name, description and slug. Defaults to en.
name?	string	Overrides the Bluestone product name.
description?	string	Overrides the Bluestone product description.
slug?	string	Overrides the slug made from the product name.
appendAttributes?	Attribute[]	Attributes added to every variant, after the sync attributes.

Returns Product$1

bodyTypeAssociates the mocked response body type with the response instance for stricter typing of the response resolvers.

import { bodyType } from "@evolve-framework/bluestone-commercetools/testing";

const bodyType: typeof bodyType

categoryFixtureA fishery factory for a Bluestone category with a random id.

import { categoryFixture } from "@evolve-framework/bluestone-commercetools/testing";

const categoryFixture: Factory<Category, any, Category, DeepPartialObject<Category>>

ctCategoryFixtureA commercetools category with one parent, named in en and fr.

import { ctCategoryFixture } from "@evolve-framework/bluestone-commercetools/testing";

const ctCategoryFixture: Category

EventMap

import { EventMap } from "@evolve-framework/bluestone-commercetools/testing";

const EventMap: any

InterceptorReadyState

import { InterceptorReadyState } from "@evolve-framework/bluestone-commercetools/testing";

const InterceptorReadyState: typeof InterceptorReadyState

kAutoConnect

import { kAutoConnect } from "@evolve-framework/bluestone-commercetools/testing";

const kAutoConnect: typeof kAutoConnect

kConnect

import { kConnect } from "@evolve-framework/bluestone-commercetools/testing";

const kConnect: typeof kConnect

kDefaultPrevented

import { kDefaultPrevented } from "@evolve-framework/bluestone-commercetools/testing";

const kDefaultPrevented: typeof kDefaultPrevented

kEmitter

import { kEmitter } from "@evolve-framework/bluestone-commercetools/testing";

const kEmitter: typeof kEmitter

kImmediatePropagationStopped

import { kImmediatePropagationStopped } from "@evolve-framework/bluestone-commercetools/testing";

const kImmediatePropagationStopped: typeof kImmediatePropagationStopped

kPropagationStopped

import { kPropagationStopped } from "@evolve-framework/bluestone-commercetools/testing";

const kPropagationStopped: typeof kPropagationStopped

mswServerAn MSW server with the handlers of the mocked commercetools project from @evolve-framework/commercetools/testing.

import { mswServer } from "@evolve-framework/bluestone-commercetools/testing";

const mswServer: SetupServer

NetworkReadyState

import { NetworkReadyState } from "@evolve-framework/bluestone-commercetools/testing";

const NetworkReadyState: typeof NetworkReadyState

productFixtureA fishery factory for a Bluestone SINGLE product with a random id.

import { productFixture } from "@evolve-framework/bluestone-commercetools/testing";

const productFixture: Factory<Product, ProductTransientParameters, Product, DeepPartialObject<Product>>

_ApplyDefaultOptions

import { type _ApplyDefaultOptions } from "@evolve-framework/bluestone-commercetools/testing";

type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;

_IsEqual

import { type _IsEqual } from "@evolve-framework/bluestone-commercetools/testing";

type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;

_Merge

import { type _Merge } from "@evolve-framework/bluestone-commercetools/testing";

type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;

_PartialDeep

import { type _PartialDeep } from "@evolve-framework/bluestone-commercetools/testing";

type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T // For functions with no properties
 : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
 ? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
 ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
 ? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
 : T // If they don't opt into array testing, just use the original type
 : PartialObjectDeep<T, Options> : unknown;

AllEventsCreates a union of all events in the EventMap with their literal type strings.

import { type AllEvents } from "@evolve-framework/bluestone-commercetools/testing";

type AllEvents<EventMap$1 extends DefaultEventMap> = { [K in keyof EventMap$1 & string]: Brand<EventMap$1[K], K>; }[keyof EventMap$1 & string];

AnyHandler

import { type AnyHandler } from "@evolve-framework/bluestone-commercetools/testing";

type AnyHandler = RequestHandler | WebSocketHandler<AnyWebSocketExtension>;

AnyNetworkFrame

import { type AnyNetworkFrame } from "@evolve-framework/bluestone-commercetools/testing";

type AnyNetworkFrame = NetworkFrame<string, unknown, any>;

AnyWebSocketExtension

import { type AnyWebSocketExtension } from "@evolve-framework/bluestone-commercetools/testing";

type AnyWebSocketExtension = WebSocketExtension<unknown, unknown>;

ApplyDefaultOptionsMerges user specified options with default options.

import { type ApplyDefaultOptions } from "@evolve-framework/bluestone-commercetools/testing";

type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
) ? Result : never;

AsyncResponseResolverReturnType

import { type AsyncResponseResolverReturnType } from "@evolve-framework/bluestone-commercetools/testing";

type AsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType> | Iterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>> | AsyncIterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>>>;

BrandBrands a TypedEvent or its subclass while preserving its (narrower) type.

import { type Brand } from "@evolve-framework/bluestone-commercetools/testing";

type Brand<Event extends TypedEvent, EventType extends string, Loose extends boolean = false> = Loose extends true ? Event extends TypedEvent<infer Data, any, any> ?
TypedEvent<Data, any, EventType> & {
  type: EventType;
} : never : Event & {
  type: EventType;
};

BuiltInsMatches any primitive, void, Date, or RegExp value.

import { type BuiltIns } from "@evolve-framework/bluestone-commercetools/testing";

type BuiltIns = Primitive | void | Date | RegExp;

CloseEventInit

import { type CloseEventInit } from "@evolve-framework/bluestone-commercetools/testing";

interface CloseEventInit extends EventInit {
  code?: number;
  reason?: string;
  wasClean?: boolean;
}

DefaultBodyType

import { type DefaultBodyType } from "@evolve-framework/bluestone-commercetools/testing";

type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;

DefaultEventMap

import { type DefaultEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type DefaultEventMap = {
  [eventType: string]: TypedEvent<any, any>;
};

DefaultPartialDeepOptions

import { type DefaultPartialDeepOptions } from "@evolve-framework/bluestone-commercetools/testing";

type DefaultPartialDeepOptions = {
  recurseIntoArrays: false;
  allowUndefinedInNonTupleArrays: false;
};

DefaultRequestMultipartBody

import { type DefaultRequestMultipartBody } from "@evolve-framework/bluestone-commercetools/testing";

type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;

DefaultUnsafeFetchResponse

import { type DefaultUnsafeFetchResponse } from "@evolve-framework/bluestone-commercetools/testing";

type DefaultUnsafeFetchResponse = Response & {
  [bodyType]?: never;
};

DisposableSubscription

import { type DisposableSubscription } from "@evolve-framework/bluestone-commercetools/testing";

type DisposableSubscription = () => void;

EmitterHookMap

import { type EmitterHookMap } from "@evolve-framework/bluestone-commercetools/testing";

type EmitterHookMap<EventMap$1 extends DefaultEventMap> = {
  newListener: (type: keyof WithReservedEvents<EventMap$1> & string, listener: { [K in keyof WithReservedEvents<EventMap$1> & string]: Emitter.Listener<Emitter<EventMap$1>, K, WithReservedEvents<EventMap$1>>; }[keyof WithReservedEvents<EventMap$1> & string], options: HookListenerOptions | undefined) => void;
  removeListener: (type: keyof WithReservedEvents<EventMap$1> & string, listener: { [K in keyof WithReservedEvents<EventMap$1> & string]: Emitter.Listener<Emitter<EventMap$1>, K, WithReservedEvents<EventMap$1>>; }[keyof WithReservedEvents<EventMap$1> & string], options: HookListenerOptions | undefined) => void;
  beforeEmit: (event: EventMap$1[keyof EventMap$1 & string]) => boolean | void;
};

FetchResponseInit

import { type FetchResponseInit } from "@evolve-framework/bluestone-commercetools/testing";

interface FetchResponseInit extends ResponseInit {
  url?: string;
}

GraphQLSubscriptionEventInit

import { type GraphQLSubscriptionEventInit } from "@evolve-framework/bluestone-commercetools/testing";

interface GraphQLSubscriptionEventInit {
  operationName: string;
  query: string;
  variables: Record<string, unknown>;
  request: Request;
}

HandlerKind

import { type HandlerKind } from "@evolve-framework/bluestone-commercetools/testing";

type HandlerKind = 'request' | 'websocket';

HandlerOfKind

import { type HandlerOfKind } from "@evolve-framework/bluestone-commercetools/testing";

type HandlerOfKind<Kind extends HandlerKind> = Extract<AnyHandler, {
  kind: Kind;
}>;

HandlersControllerState

import { type HandlersControllerState } from "@evolve-framework/bluestone-commercetools/testing";

interface HandlersControllerState {
  initialHandlers: HandlersMap;
  handlers: HandlersMap;
}

HandlersMap

import { type HandlersMap } from "@evolve-framework/bluestone-commercetools/testing";

type HandlersMap = HandlersMapOfKind<HandlerKind>;

HandlersMapOfKind

import { type HandlersMapOfKind } from "@evolve-framework/bluestone-commercetools/testing";

type HandlersMapOfKind<Kind extends HandlerKind> = { [K in Kind]?: Array<HandlerOfKind<K>>; };

HasMultipleCallSignaturesTest if the given function has multiple call signatures.

import { type HasMultipleCallSignatures } from "@evolve-framework/bluestone-commercetools/testing";

Needed to handle the case of a single call signature with properties.

Multiple call signatures cannot currently be supported due to a TypeScript limitation.

type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
  (...arguments_: infer A): unknown;
  (...arguments_: infer B): unknown;
} ? B extends A ? A extends B ? false : true : true : false;

HookListenerOptions

import { type HookListenerOptions } from "@evolve-framework/bluestone-commercetools/testing";

interface HookListenerOptions extends TypedListenerOptions {
  persist?: boolean;
}

HttpNetworkFrameEventMap

import { type HttpNetworkFrameEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type HttpNetworkFrameEventMap = {
  'request:start': RequestEvent;
  'request:match': RequestEvent;
  'request:unhandled': RequestEvent;
  'request:end': RequestEvent;
  'response:mocked': ResponseEvent;
  'response:bypass': ResponseEvent;
  unhandledException: UnhandledExceptionEvent;
};

HttpResponseInit

import { type HttpResponseInit } from "@evolve-framework/bluestone-commercetools/testing";

interface HttpResponseInit extends ResponseInit {
  type?: ResponseType;
}

IfAn if-else-like type that resolves depending on whether the given boolean type is true or false.

import { type If } from "@evolve-framework/bluestone-commercetools/testing";

Use-cases:

• You can use this in combination with Is* types to create an if-else-like experience. For example, If<IsAny<any>, 'is any', 'not any'>.

Note:

• Returns a union of if branch and else branch if the given type is boolean or any. For example, If<boolean, 'Y', 'N'> will return 'Y' | 'N'.
• Returns the else branch if the given type is never. For example, If<never, 'Y', 'N'> will return 'N'.

type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;

InferEventMap

import { type InferEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type InferEventMap<Target extends Emitter<any>> = Target extends Emitter<infer EventMap> ? WithReservedEvents<EventMap> : never;

IsAnyReturns a boolean for whether the given type is any.

import { type IsAny } from "@evolve-framework/bluestone-commercetools/testing";

type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;

IsEqualReturns a boolean for whether the two given types are equal.

import { type IsEqual } from "@evolve-framework/bluestone-commercetools/testing";

type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;

IsNeverReturns a boolean for whether the given type is never.

import { type IsNever } from "@evolve-framework/bluestone-commercetools/testing";

type IsNever<T> = [T] extends [never] ? true : false;

IsOptionalKeyOfReturns a boolean for whether the given key is an optional key of type.

import { type IsOptionalKeyOf } from "@evolve-framework/bluestone-commercetools/testing";

This is useful when writing utility types or schema validators that need to differentiate optional keys.

type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;

IsReservedEvent

import { type IsReservedEvent } from "@evolve-framework/bluestone-commercetools/testing";

type IsReservedEvent<Type extends string> = Type extends keyof ReservedEventMap ? true : false;

JsonBodyType

import { type JsonBodyType } from "@evolve-framework/bluestone-commercetools/testing";

type JsonBodyType = Record<string, any> | string | number | boolean | null | undefined;

LifeCycleEventEmitter

import { type LifeCycleEventEmitter } from "@evolve-framework/bluestone-commercetools/testing";

type LifeCycleEventEmitter<EventMap extends DefaultEventMap> = Pick<Emitter<EventMap>, 'on' | 'removeListener' | 'removeAllListeners'>;

Logger

import { type Logger } from "@evolve-framework/bluestone-commercetools/testing";

interface Logger {
  info(message: string, ...positionals: Array<unknown>): void;
  verbose(message: string, ...positionals: Array<unknown>): void;
  isEnabled(level: LogLevel): boolean;
}

LogLevel

import { type LogLevel } from "@evolve-framework/bluestone-commercetools/testing";

type LogLevel = 'default' | 'verbose';

Match

import { type Match } from "@evolve-framework/bluestone-commercetools/testing";

interface Match {
  matches: boolean;
  params?: PathParams;
}

MaybeAsyncResponseResolverReturnType

import { type MaybeAsyncResponseResolverReturnType } from "@evolve-framework/bluestone-commercetools/testing";

type MaybeAsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>;

MaybePromise

import { type MaybePromise } from "@evolve-framework/bluestone-commercetools/testing";

type MaybePromise<T> = T | Promise<T>;

MergeMerge two types into a new type.

import { type Merge } from "@evolve-framework/bluestone-commercetools/testing";

This is different from the TypeScript & (intersection) operator. With &, conflicting property types are intersected, which often results in never. For example, {a: string} & {a: number} makes a become string & number, which resolves to never. With Merge, the second type's keys cleanly override the first, so Merge<{a: string}, {a: number}> gives {a: number} as expected. Merge also produces a flattened type (via Simplify), making it more readable in IDE tooltips compared to A & B.

type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
 ? Source extends unknown // For distributing `Source`
 ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
 : never;

NetworkFrameResolutionContext

import { type NetworkFrameResolutionContext } from "@evolve-framework/bluestone-commercetools/testing";

interface NetworkFrameResolutionContext {
  baseUrl?: string | URL;
  quiet?: boolean;
}

OmitIndexSignatureOmit any index signatures from the given object type, leaving only explicitly defined properties.

import { type OmitIndexSignature } from "@evolve-framework/bluestone-commercetools/testing";

This is the counterpart of PickIndexSignature.

Use-cases:

• Remove overly permissive signatures from third-party types.

This type was taken from this StackOverflow answer.

It relies on the fact that an empty object ({}) is assignable to an object with just an index signature, like Record<string, unknown>, but not to an object with explicitly defined keys, like Record<'foo' | 'bar', unknown>.

(The actual value type, unknown, is irrelevant and could be any type. Only the key type matters.)

const indexed: Record<string, unknown> = {}; // Allowed

//

type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };

OptionalKeysOfExtract all optional keys from the given type.

import { type OptionalKeysOf } from "@evolve-framework/bluestone-commercetools/testing";

This is useful when you want to create a new type that contains different type values for the optional keys only.

type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
 ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never; }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;

PartialDeepCreate a deeply optional version of another type.

import { type PartialDeep } from "@evolve-framework/bluestone-commercetools/testing";

Use-cases:

• Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
• Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.

Use Partial<T> if you only need one level deep.

type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;

PartialDeepOptions

import { type PartialDeepOptions } from "@evolve-framework/bluestone-commercetools/testing";

type PartialDeepOptions = {
  readonly recurseIntoArrays?: boolean;
  readonly allowUndefinedInNonTupleArrays?: boolean;
};

PartialMapDeepSame as PartialDeep, but accepts only Maps and as inputs.

import { type PartialMapDeep } from "@evolve-framework/bluestone-commercetools/testing";

type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;

PartialObjectDeepSame as PartialDeep, but accepts only objects as inputs.

import { type PartialObjectDeep } from "@evolve-framework/bluestone-commercetools/testing";

type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = { [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>; };

PartialReadonlyMapDeepSame as PartialDeep, but accepts only ReadonlyMaps as inputs.

import { type PartialReadonlyMapDeep } from "@evolve-framework/bluestone-commercetools/testing";

type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;

PartialReadonlySetDeepSame as PartialDeep, but accepts only ReadonlySets as inputs.

import { type PartialReadonlySetDeep } from "@evolve-framework/bluestone-commercetools/testing";

type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;

PartialSetDeepSame as PartialDeep, but accepts only Sets as inputs.

import { type PartialSetDeep } from "@evolve-framework/bluestone-commercetools/testing";

type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;

Path

import { type Path } from "@evolve-framework/bluestone-commercetools/testing";

type Path = string | RegExp;

PathParams

import { type PathParams } from "@evolve-framework/bluestone-commercetools/testing";

type PathParams<KeyType extends keyof any = string> = { [ParamName in KeyType]?: string | ReadonlyArray<string>; };

PickIndexSignaturePick only index signatures from the given object type, leaving out all explicitly defined properties.

import { type PickIndexSignature } from "@evolve-framework/bluestone-commercetools/testing";

This is the counterpart of OmitIndexSignature.

type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };

PrimitiveMatches any primitive value.

import { type Primitive } from "@evolve-framework/bluestone-commercetools/testing";

type Primitive = null | undefined | string | number | boolean | symbol | bigint;

ProductTransientParameters

import { type ProductTransientParameters } from "@evolve-framework/bluestone-commercetools/testing";

type ProductTransientParameters = {
  attributes?: Attribute[];
};

RequestHandlerArgs

import { type RequestHandlerArgs } from "@evolve-framework/bluestone-commercetools/testing";

interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
  info: HandlerInfo;
  resolver: ResponseResolver<any>;
  options?: HandlerOptions;
}

RequestHandlerDefaultInfo

import { type RequestHandlerDefaultInfo } from "@evolve-framework/bluestone-commercetools/testing";

interface RequestHandlerDefaultInfo {
  header: string;
}

RequestHandlerExecutionResult

import { type RequestHandlerExecutionResult } from "@evolve-framework/bluestone-commercetools/testing";

interface RequestHandlerExecutionResult<ParsedResult extends object | undefined> {
  handler: RequestHandler;
  parsedResult?: ParsedResult;
  request: Request;
  requestId: string;
  response?: Response;
}

RequestHandlerInternalInfo

import { type RequestHandlerInternalInfo } from "@evolve-framework/bluestone-commercetools/testing";

interface RequestHandlerInternalInfo {
  callFrame?: string;
}

RequestHandlerOptions

import { type RequestHandlerOptions } from "@evolve-framework/bluestone-commercetools/testing";

interface RequestHandlerOptions {
  once?: boolean;
}

RequiredKeysOfExtract all required keys from the given type.

import { type RequiredKeysOf } from "@evolve-framework/bluestone-commercetools/testing";

This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...

type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
 ? Exclude<keyof Type, OptionalKeysOf<Type>> : never;

ReservedEventMapReserved event map containing special event types like '*' for catch-all listeners.

import { type ReservedEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type ReservedEventMap = {
  '*': TypedEvent<any, any, '*'>;
};

ResponseResolutionContext

import { type ResponseResolutionContext } from "@evolve-framework/bluestone-commercetools/testing";

interface ResponseResolutionContext {
  baseUrl?: string;
  quiet?: boolean;
}

ResponseResolver

import { type ResponseResolver } from "@evolve-framework/bluestone-commercetools/testing";

type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;

ResponseResolverFinalizeFunction

import { type ResponseResolverFinalizeFunction } from "@evolve-framework/bluestone-commercetools/testing";

type ResponseResolverFinalizeFunction = (callback: () => MaybePromise<void>) => void;

ResponseResolverInfo

import { type ResponseResolverInfo } from "@evolve-framework/bluestone-commercetools/testing";

type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
  request: StrictRequest<RequestBodyType>;
  requestId: string;
  finalize: ResponseResolverFinalizeFunction;
} & ResolverExtraInfo;

ResponseResolverReturnType

import { type ResponseResolverReturnType } from "@evolve-framework/bluestone-commercetools/testing";

type ResponseResolverReturnType<ResponseBodyType extends DefaultBodyType = undefined> = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends Record<string, any> | undefined ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse : HttpResponse<ResponseBodyType>) | undefined | void;

SetupServer

import { type SetupServer } from "@evolve-framework/bluestone-commercetools/testing";

interface SetupServer extends SetupServerCommon {
  boundary: <Args extends Array<any>, R>(callback: (...args: Args) => R) => (...args: Args) => R;
}

SetupServerCommon

import { type SetupServerCommon } from "@evolve-framework/bluestone-commercetools/testing";

interface SetupServerCommon {
  readonly readyState: NetworkReadyState;
  listen: (options?: PartialDeep<SharedOptions>) => void;
  close: () => void;
  use: (...handlers: Array<AnyHandler>) => void;
  restoreHandlers: () => void;
  resetHandlers: (...nextHandlers: Array<AnyHandler>) => void;
  listHandlers: () => ReadonlyArray<AnyHandler>;
  events: LifeCycleEventEmitter<HttpNetworkFrameEventMap & WebSocketNetworkFrameEventMap>;
}

SharedOptions

import { type SharedOptions } from "@evolve-framework/bluestone-commercetools/testing";

interface SharedOptions {
  onUnhandledFrame?: UnhandledFrameHandle;
}

SimpleMerge

import { type SimpleMerge } from "@evolve-framework/bluestone-commercetools/testing";

type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key]; } & Source>;

SimplifyUseful to flatten the type output to improve type hints shown in editors.

import { type Simplify } from "@evolve-framework/bluestone-commercetools/testing";

type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};

StrictRequest

import { type StrictRequest } from "@evolve-framework/bluestone-commercetools/testing";

interface StrictRequest<BodyType extends JsonBodyType> extends Request {
  json(): Promise<BodyType>;
  clone(): StrictRequest<BodyType>;
}

TransparentNoInferBlocks inference from the annotated position, like the built-in NoInfer, but resolves to a plain type once instantiated.

import { type TransparentNoInfer } from "@evolve-framework/bluestone-commercetools/testing";

type TransparentNoInfer<T> = [T][T extends any ? 0 : never];

TypedListenerOptions

import { type TypedListenerOptions } from "@evolve-framework/bluestone-commercetools/testing";

type TypedListenerOptions = {
  once?: boolean;
  signal?: AbortSignal;
};

UnhandledFrameCallback

import { type UnhandledFrameCallback } from "@evolve-framework/bluestone-commercetools/testing";

type UnhandledFrameCallback = (args: {
  frame: AnyNetworkFrame;
  defaults: UnhandledFrameDefaults;
}) => Promise<void> | void;

UnhandledFrameDefaults

import { type UnhandledFrameDefaults } from "@evolve-framework/bluestone-commercetools/testing";

type UnhandledFrameDefaults = {
  warn: () => void;
  error: () => void;
};

UnhandledFrameHandle

import { type UnhandledFrameHandle } from "@evolve-framework/bluestone-commercetools/testing";

type UnhandledFrameHandle = UnhandledFrameStrategy | UnhandledFrameCallback;

UnhandledFrameStrategy

import { type UnhandledFrameStrategy } from "@evolve-framework/bluestone-commercetools/testing";

type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error';

UserEventMapExtracts only user-defined events, excluding reserved event types.

import { type UserEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type UserEventMap<EventMap$1 extends DefaultEventMap> = Omit<EventMap$1, keyof ReservedEventMap>;

WebSocketClientEventMap

import { type WebSocketClientEventMap } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketClientEventMap<Message = WebSocketData> {
  open: Event;
  message: MessageEvent<Message>;
  close: CloseEvent;
}

WebSocketConnectionEventDataAn intercepted WebSocket connection: the client and the server handles.

import { type WebSocketConnectionEventData } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketConnectionEventData<Message = WebSocketData> {
  client: WebSocketClientHandle<Message>;
  server: WebSocketServerHandle<Message>;
  info: WebSocketConnectionInfo;
}

WebSocketConnectionInfoThe connection information.

import { type WebSocketConnectionInfo } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketConnectionInfo {
  protocols: string | Array<string> | undefined;
}

WebSocketData

import { type WebSocketData } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketData = string | ArrayBuffer | Blob | ArrayBufferView<ArrayBuffer>;

WebSocketEventListener

import { type WebSocketEventListener } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketEventListener<EventType extends Event = Event> = (this: WebSocket, event: EventType) => void;

WebSocketExtensionApiThe API the given extension adds to the connection event.

import { type WebSocketExtensionApi } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketExtensionApi<Extension> = Extension extends WebSocketExtension<unknown, infer Api> ? Api : never;

WebSocketExtensionContextThe intercepted connection an extension operates on.

import { type WebSocketExtensionContext } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketExtensionContext<Message = WebSocketData> {
  client: WebSocketClientHandle<Message>;
  server: WebSocketServerHandle<Message>;
  info: WebSocketConnectionInfo;
}

WebSocketExtensionMessageThe messages the given extension encodes and decodes.

import { type WebSocketExtensionMessage } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketExtensionMessage<Extension> = Extension extends {
  encode(message: infer Message, context: never): unknown;
} ? Message : never;

WebSocketExtensionMessageContext

import { type WebSocketExtensionMessageContext } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketExtensionMessageContext<Message = WebSocketData> extends WebSocketExtensionContext<Message> {
  connection: WebSocketClientHandle<Message> | WebSocketServerHandle<Message>;
}

WebSocketExtensionResultThe result of an extension method: a single value, an iterator over multiple values, or undefined for no values at all.

import { type WebSocketExtensionResult } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketExtensionResult<Value> = Value | Iterator<Value, Value | void> | undefined;

WebSocketHandlerConnectionThe connection matched by a handler.

import { type WebSocketHandlerConnection } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketHandlerConnection<Message = WebSocketData> {
  client: WebSocketClientHandle<Message>;
  server: WebSocketServerHandle<Message>;
  info: WebSocketConnectionInfo;
  params: PathParams;
}

WebSocketHandlerConnectionEventThe connection event of a handler with the given extension: the connection speaks the extension's messages and the event carries the extension's own API (e.g.

import { type WebSocketHandlerConnectionEvent } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketHandlerConnectionEvent<Extension extends AnyWebSocketExtension = WebSocketExtension> = WebSocketConnectionEvent<WebSocketExtensionMessage<Extension>> & WebSocketExtensionApi<Extension>;

WebSocketHandlerEventMap

import { type WebSocketHandlerEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketHandlerEventMap<Extension extends AnyWebSocketExtension = WebSocketExtension> = {
  connection: WebSocketHandlerConnectionEvent<Extension>;
};

WebSocketHandlerParsedResult

import { type WebSocketHandlerParsedResult } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketHandlerParsedResult = {
  match: Match;
};

WebSocketHandlerResolvedConnectionThe connection resolved by a handler: the matched connection extended with the handler extension's own API.

import { type WebSocketHandlerResolvedConnection } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketHandlerResolvedConnection<Extension extends AnyWebSocketExtension = WebSocketExtension> = WebSocketHandlerConnection<WebSocketExtensionMessage<Extension>> & WebSocketExtensionApi<Extension>;

WebSocketNetworkFrameEventMap

import { type WebSocketNetworkFrameEventMap } from "@evolve-framework/bluestone-commercetools/testing";

type WebSocketNetworkFrameEventMap = {
  'websocket:connection': WebSocketConnectionEvent$1;
  'websocket:error': WebSocketErrorEvent;
  'graphql:subscription': GraphQLSubscriptionEvent;
  unhandledException: WebSocketErrorEvent;
};

WebSocketResolutionContext

import { type WebSocketResolutionContext } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketResolutionContext {
  baseUrl?: string;
  events?: Pick<Emitter<WebSocketNetworkFrameEventMap>, 'emit'>;
  [kAutoConnect]?: boolean;
}

WebSocketServerEventMap

import { type WebSocketServerEventMap } from "@evolve-framework/bluestone-commercetools/testing";

interface WebSocketServerEventMap<Message = WebSocketData> {
  open: Event;
  message: MessageEvent<Message>;
  error: Event;
  close: CloseEvent;
}

WithReservedEventsDecorates the given EventMap with the reserved emitter events (e.g.

import { type WithReservedEvents } from "@evolve-framework/bluestone-commercetools/testing";

type WithReservedEvents<EventMap$1 extends DefaultEventMap> = EventMap$1 & ReservedEventMap;