• Version 7.0.1
  • Published
  • 438 kB
  • 2 dependencies
  • MIT license


npm i rxjs-marbles
yarn add rxjs-marbles
pnpm add rxjs-marbles


An RxJS marble testing library for any test framework



variable marbles

const marbles: MarblesFunction;


    function configure

    configure: {
    (configuration: Configuration): { marbles: MarblesFunction };
    <T>(factory: (t: T) => Configuration): { marbles: MarblesFunction };

      function defaults

      defaults: () => Configuration;


        class Expect

        class Expect<T> {}


          actual: Observable<T>,
          helpers: ExpectHelpers,
          subscription?: string

            method toBeObservable

            toBeObservable: {
            (expected: TestObservableLike<T>): void;
            (expected: string, values?: { [key: string]: T }, error?: any): void;

              method toHaveSubscriptions

              toHaveSubscriptions: (expected: string | string[]) => void;


                interface Configuration

                interface Configuration {}

                  property assert

                  assert?: (value: any, message: string) => void;

                    property assertDeepEqual

                    assertDeepEqual?: (a: any, b: any) => void;

                      property frameworkMatcher

                      frameworkMatcher?: boolean;

                        property run

                        run?: boolean;

                          interface Context

                          interface Context {}

                            property autoFlush

                            autoFlush: boolean;

                              property scheduler

                              readonly scheduler: TestScheduler;

                                method bind

                                bind: (...schedulers: SchedulerLike[]) => void;

                                  method cold

                                  cold: <T = any>(
                                  marbles: string,
                                  values?: { [key: string]: T },
                                  error?: any
                                  ) => TestObservableLike<T>;

                                    method configure

                                    configure: (configuration: Configuration) => void;

                                      method equal

                                      equal: {
                                      <T = any>(actual: Observable<T>, expected: TestObservableLike<T>): void;
                                      <T = any>(
                                      actual: Observable<T>,
                                      expected: string,
                                      values?: { [key: string]: T },
                                      error?: any
                                      ): void;
                                      <T = any>(actual: Observable<T>, subscription: string, expected: any): void;
                                      <T = any>(
                                      actual: Observable<T>,
                                      subscription: string,
                                      expected: string,
                                      values?: { [key: string]: T },
                                      error?: any
                                      ): void;

                                        method expect

                                        expect: <T = any>(actual: Observable<T>, subscription?: string) => Expect<T>;

                                          method flush

                                          flush: () => void;

                                            method has

                                            has: <T = any>(actual: Observable<T>, expected: string | string[]) => void;

                                              method hot

                                              hot: <T = any>(
                                              marbles: string,
                                              values?: { [key: string]: T },
                                              error?: any
                                              ) => TestObservableLike<T>;

                                                method reframe

                                                reframe: (timePerFrame: number, maxTime?: number) => void;

                                                  method teardown

                                                  teardown: () => void;

                                                    method time

                                                    time: (marbles: string) => number;

                                                      interface MarblesFunction

                                                      interface MarblesFunction {}

                                                        call signature

                                                        (func: (context: Context) => any): () => any;

                                                          call signature

                                                          <T>(func: (context: Context, t: T) => any): (t: T) => any;

                                                            call signature

                                                            (func: (context: Context, ...rest: any[]) => any): (...rest: any[]) => any;

                                                              Package Files (5)

                                                              Dependencies (2)

                                                              Dev Dependencies (0)

                                                              No dev dependencies.

                                                              Peer Dependencies (1)


                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/rxjs-marbles.

                                                              • Markdown
                                                              • HTML
                                                                <a href="https://www.jsdocs.io/package/rxjs-marbles"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>