Home Manual Reference Source Test Repository

spec-js/operators/retryWhen-spec.js

"use strict";
var chai_1 = require('chai');
var Rx = require('../../dist/package/Rx');
var Observable = Rx.Observable;
/** @test {retryWhen} */
describe('Observable.prototype.retryWhen', function () {
    asDiagram('retryWhen')('should handle a source with eventual error using a hot notifier', function () {
        var source = cold('-1--2--#');
        var subs = ['^      !                     ',
            '             ^      !        ',
            '                          ^ !'];
        var notifier = hot('-------------r------------r-|');
        var expected = '-1--2---------1--2---------1|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should handle a source with eventual error using a hot notifier that raises error', function () {
        var source = cold('-1--2--#');
        var subs = ['^      !                    ',
            '           ^      !           ',
            '                   ^      !   '];
        var notifier = hot('-----------r-------r---------#');
        var expected = '-1--2-------1--2----1--2-----#';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should retry when notified via returned notifier on thrown error', function (done) {
        var retried = false;
        var expected = [1, 2, 1, 2];
        var i = 0;
        Observable.of(1, 2, 3)
            .map(function (n) {
            if (n === 3) {
                throw 'bad';
            }
            return n;
        })
            .retryWhen(function (errors) { return errors.map(function (x) {
            chai_1.expect(x).to.equal('bad');
            if (retried) {
                throw new Error('done');
            }
            retried = true;
            return x;
        }); })
            .subscribe(function (x) {
            chai_1.expect(x).to.equal(expected[i++]);
        }, function (err) {
            chai_1.expect(err).to.be.an('error', 'done');
            done();
        });
    });
    it('should retry when notified and complete on returned completion', function (done) {
        var expected = [1, 2, 1, 2];
        Observable.of(1, 2, 3)
            .map(function (n) {
            if (n === 3) {
                throw 'bad';
            }
            return n;
        })
            .retryWhen(function (errors) { return Observable.empty(); })
            .subscribe(function (n) {
            chai_1.expect(n).to.equal(expected.shift());
        }, function (err) {
            done(new Error('should not be called'));
        }, function () {
            done();
        });
    });
    it('should apply an empty notifier on an empty source', function () {
        var source = cold('|');
        var subs = '(^!)';
        var notifier = cold('|');
        var expected = '|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should apply a never notifier on an empty source', function () {
        var source = cold('|');
        var subs = '(^!)';
        var notifier = cold('-');
        var expected = '|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should apply an empty notifier on a never source', function () {
        var source = cold('-');
        var unsub = '                                         !';
        var subs = '^                                        !';
        var notifier = cold('|');
        var expected = '-';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result, unsub).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should apply a never notifier on a never source', function () {
        var source = cold('-');
        var unsub = '                                         !';
        var subs = '^                                        !';
        var notifier = cold('-');
        var expected = '-';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result, unsub).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should return an empty observable given a just-throw source and empty notifier', function () {
        var source = cold('#');
        var notifier = cold('|');
        var expected = '|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
    });
    it('should return a never observable given a just-throw source and never notifier', function () {
        var source = cold('#');
        var notifier = cold('-');
        var expected = '-';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
    });
    it('should hide errors using a never notifier on a source with eventual error', function () {
        var source = cold('--a--b--c--#');
        var subs = '^          !';
        var notifier = cold('-');
        var expected = '--a--b--c---------------------------------';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should propagate error thrown from notifierSelector function', function () {
        var source = cold('--a--b--c--#');
        var subs = '^          !';
        var expected = '--a--b--c--#';
        var result = source.retryWhen((function () { throw 'bad!'; }));
        expectObservable(result).toBe(expected, undefined, 'bad!');
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should replace error with complete using an empty notifier on a source ' +
        'with eventual error', function () {
        var source = cold('--a--b--c--#');
        var subs = '^          !';
        var notifier = cold('|');
        var expected = '--a--b--c--|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should mirror a basic cold source with complete, given a never notifier', function () {
        var source = cold('--a--b--c--|');
        var subs = '^          !';
        var notifier = cold('|');
        var expected = '--a--b--c--|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should mirror a basic cold source with no termination, given a never notifier', function () {
        var source = cold('--a--b--c---');
        var subs = '^           ';
        var notifier = cold('|');
        var expected = '--a--b--c---';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should mirror a basic hot source with complete, given a never notifier', function () {
        var source = hot('-a-^--b--c--|');
        var subs = '^        !';
        var notifier = cold('|');
        var expected = '---b--c--|';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should handle a hot source that raises error but eventually completes', function () {
        var source = hot('-1--2--3----4--5---|');
        var ssubs = ['^      !            ',
            '              ^    !'];
        var notifier = hot('--------------r--------r---r--r--r---|');
        var nsubs = '       ^           !';
        var expected = '-1--2---      -5---|';
        var result = source
            .map(function (x) {
            if (x === '3') {
                throw 'error';
            }
            return x;
        }).retryWhen(function () { return notifier; });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(ssubs);
        expectSubscriptions(notifier.subscriptions).toBe(nsubs);
    });
    it('should tear down resources when result is unsubscribed early', function () {
        var source = cold('-1--2--#');
        var unsub = '                    !       ';
        var subs = ['^      !                    ',
            '         ^      !           ',
            '                 ^  !       '];
        var notifier = hot('---------r-------r---------#');
        var nsubs = '       ^            !       ';
        var expected = '-1--2-----1--2----1--       ';
        var result = source.retryWhen(function (errors) { return notifier; });
        expectObservable(result, unsub).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
        expectSubscriptions(notifier.subscriptions).toBe(nsubs);
    });
    it('should not break unsubscription chains when unsubscribed explicitly', function () {
        var source = cold('-1--2--#');
        var subs = ['^      !                    ',
            '         ^      !           ',
            '                 ^  !       '];
        var notifier = hot('---------r-------r-------r-#');
        var nsubs = '       ^            !       ';
        var expected = '-1--2-----1--2----1--       ';
        var unsub = '                    !       ';
        var result = source
            .mergeMap(function (x) { return Observable.of(x); })
            .retryWhen(function (errors) { return notifier; })
            .mergeMap(function (x) { return Observable.of(x); });
        expectObservable(result, unsub).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
        expectSubscriptions(notifier.subscriptions).toBe(nsubs);
    });
    it('should handle a source with eventual error using a dynamic notifier ' +
        'selector which eventually throws', function () {
        var source = cold('-1--2--#');
        var subs = ['^      !              ',
            '       ^      !       ',
            '              ^      !'];
        var expected = '-1--2---1--2---1--2--#';
        var invoked = 0;
        var result = source.retryWhen(function (errors) {
            return errors.map(function (err) {
                if (++invoked === 3) {
                    throw 'error';
                }
                else {
                    return 'x';
                }
            });
        });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
    it('should handle a source with eventual error using a dynamic notifier ' +
        'selector which eventually completes', function () {
        var source = cold('-1--2--#');
        var subs = ['^      !              ',
            '       ^      !       ',
            '              ^      !'];
        var expected = '-1--2---1--2---1--2--|';
        var invoked = 0;
        var result = source.retryWhen(function (errors) { return errors
            .map(function () { return 'x'; })
            .takeUntil(errors.flatMap(function () {
            if (++invoked < 3) {
                return Observable.empty();
            }
            else {
                return Observable.of('stop!');
            }
        })); });
        expectObservable(result).toBe(expected);
        expectSubscriptions(source.subscriptions).toBe(subs);
    });
});
//# sourceMappingURL=retryWhen-spec.js.map