rx-sandbox/dist/scheduler/createTestScheduler.d.ts

Marble diagram DSL based test suite for RxJS 6/7

import { SchedulerLike, VirtualTimeScheduler } from 'rxjs';
import { Observable } from 'rxjs';
import { ReturnTypeWithArgs } from '../interfaces/ReturnTypeWithArgs';
import { TestMessage } from '../message/TestMessage';
import { ColdObservable, HotObservable } from '../utils/coreInternalImport';
/**
 * State to be bind into each function we'll create for testscheduler.
 */
interface SandboxState {
    coldObservables: Array<ColdObservable<any>>;
    hotObservables: Array<HotObservable<any>>;
    flushed: boolean;
    flushing: boolean;
    maxFrame: Readonly<number>;
    frameTimeFactor: number;
    scheduler: VirtualTimeScheduler;
    autoFlush: boolean;
}
/**
 * Creates `createColdObservable` function.
 */
declare const getCreateColdObservable: (state: SandboxState) => {
    <T = string>(marble: string, value?: {
        [key: string]: T;
    } | null | undefined, error?: any): ColdObservable<T>;
    <T_1 = string>(message: TestMessage<T_1>[]): ColdObservable<T_1>;
};
/**
 * Creates `createHotObservable` function.
 */
declare const getCreateHotObservable: (state: SandboxState) => {
    <T = string>(marble: string, value?: {
        [key: string]: T;
    } | null | undefined, error?: any): HotObservable<T>;
    <T_1 = string>(message: TestMessage<T_1>[]): HotObservable<T_1>;
};
/**
 * Create `flush` functions for given scheduler. If `flushWithAsyncTick` specified,
 * will create flush function to schedule individual actions into native tick.
 *
 * As we don't inherit virtualtimescheduler anymore, only these functions should be
 * used to properly flush out actions. Calling `scheduler.flush()` will not do any work.
 */
declare function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: true): {
    flushUntil: (toFrame?: number) => Promise<void>;
    advanceTo: (toFrame?: number) => Promise<void>;
};
declare function getSchedulerFlushFunctions(state: SandboxState, flushWithAsyncTick: false): {
    flushUntil: (toFrame?: number) => void;
    advanceTo: (toFrame?: number) => void;
};
type getMessages = <T = string>(observable: Observable<T>, unsubscriptionMarbles?: string | null) => Array<TestMessage<T | Array<TestMessage<T>>>>;
type getMessagesWithTick = <T = string>(observable: Observable<T>, unsubscriptionMarbles?: string | null) => Promise<Array<TestMessage<T | Array<TestMessage<T>>>>>;
/**
 * create getMessages function. Depends on flush, this'll either work asynchronously or synchronously.
 */
declare function createGetMessages(state: SandboxState, flush: () => Promise<any>): getMessagesWithTick;
declare function createGetMessages(state: SandboxState, flush: () => void): getMessages;
interface BaseSchedulerInstance {
    /**
     * Test scheduler created for sandbox instance
     */
    scheduler: SchedulerLike;
    /**
     * Creates a hot observable using marble diagram DSL, or TestMessage.
     */
    hot: ReturnType<typeof getCreateHotObservable>;
    /**
     * Creates a cold obsrevable using marbld diagram DSL, or TestMessage.
     */
    cold: ReturnType<typeof getCreateColdObservable>;
    /**
     * Maxmium frame number scheduler will flush into.
     */
    maxFrame: number;
}
interface SchedulerInstance extends BaseSchedulerInstance {
    /**
     * Flush out currently scheduled observables, only until reaches frame specfied.
     */
    advanceTo: ReturnType<typeof getSchedulerFlushFunctions>['advanceTo'];
    /**
     * Flush out currently scheduled observables, fill values returned by `getMarbles`.
     */
    flush: () => void;
    /**
     * Get array of observable value's metadata TestMessage<T> from observable
     * created via `hot` or `cold`. Returned array will be filled once scheduler flushes
     * scheduled actions, either via explicit `flush` or implicit `autoFlush`.
     */
    getMessages: ReturnType<typeof createGetMessages>;
}
interface AsyncSchedulerInstance extends BaseSchedulerInstance {
    /**
     * Flush out currently scheduled observables, only until reaches frame specfied.
     */
    advanceTo: ReturnTypeWithArgs<typeof getSchedulerFlushFunctions, [SandboxState, true]>['advanceTo'];
    /**
     * Flush out currently scheduled observables, fill values returned by `getMarbles`.
     */
    flush: () => Promise<void>;
    /**
     * Get array of observable value's metadata TestMessage<T> from observable
     * created via `hot` or `cold`. Returned array will be filled once scheduler flushes
     * scheduled actions, either via explicit `flush` or implicit `autoFlush`.
     */
    getMessages: ReturnTypeWithArgs<typeof createGetMessages, [SandboxState, () => Promise<void>]>;
}
/**
 * Creates a new instance of virtualScheduler, along with utility functions for sandbox assertions.
 */
declare function createTestScheduler(autoFlush: boolean, frameTimeFactor: number, maxFrameValue: number, flushWithAsyncTick: true): AsyncSchedulerInstance;
declare function createTestScheduler(autoFlush: boolean, frameTimeFactor: number, maxFrameValue: number, flushWithAsyncTick: false): SchedulerInstance;
export { createTestScheduler, SchedulerInstance, AsyncSchedulerInstance };
//# sourceMappingURL=createTestScheduler.d.ts.map