@ama-sdk/core 12.1.8 → 12.1.11

package/esm2015/plugins/retry/retry.spec.js

@@ -28,7 +28,7 @@ function _async_to_generator(fn) {
     };
 }
 function _ts_generator(thisArg, body) {
-    var f, y, t, g, _ = {
+    var f, y, t, _ = {
         label: 0,
         sent: function() {
             if (t[0] & 1) throw t[1];
@@ -36,12 +36,8 @@ function _ts_generator(thisArg, body) {
         },
         trys: [],
         ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
         return this;
     }), g;
     function verb(n) {
@@ -54,7 +50,7 @@ function _ts_generator(thisArg, body) {
     }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [
                 op[0] & 2,
@@ -124,221 +120,233 @@ function _ts_generator(thisArg, body) {
 }
 import { RetryFetch } from './retry.fetch';
 describe('Retry Fetch Plugin', function() {
-    it('should not retry on success', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runner, call, res, ret;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(1, condition);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: true
-                    });
-                    res = runner.transform(call);
-                    expect(condition).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    ret = _state.sent();
-                    expect(ret).toEqual({
-                        text: 'test',
-                        ok: true
-                    });
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should not retry if refused by the condition', /*#__PURE__*/ _async_to_generator(function() {
-        var conditionFalsy, plugin, runner, call, res;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    conditionFalsy = jest.fn().mockReturnValue(false);
-                    plugin = new RetryFetch(3, conditionFalsy);
-                    runner = plugin.load({
-                        url: 'http://www.test.com',
-                        fetchPlugins: []
-                    });
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false,
-                        clone: function() {
-                            return {};
-                        }
-                    });
-                    res = runner.transform(call);
-                    return [
-                        4,
-                        res
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(conditionFalsy).toHaveBeenCalledTimes(1);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(2, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on fetch rejection with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new RetryFetch(2, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.reject(new Error(JSON.stringify({
-                        text: 'test',
-                        ok: true
-                    })));
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(2);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    plugin = new RetryFetch(3, condition);
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.runAllTimersAsync()
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
-    it('should retry on not ok call with wait', /*#__PURE__*/ _async_to_generator(function() {
-        var condition, delay, plugin, runners, runner, call, callback;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    condition = jest.fn().mockReturnValue(true);
-                    delay = 500;
-                    plugin = new RetryFetch(3, condition, function() {
-                        return delay;
-                    });
-                    runners = [];
-                    runner = plugin.load({
-                        url: 'not an url',
-                        fetchPlugins: runners
-                    });
-                    runners.push(runner);
-                    call = Promise.resolve({
-                        text: 'test',
-                        ok: false
-                    });
-                    callback = jest.fn();
-                    runner.transform(call).catch(callback);
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(2 * delay)
-                    ];
-                case 1:
-                    _state.sent();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [
-                        4,
-                        jest.advanceTimersByTimeAsync(delay)
-                    ];
-                case 2:
-                    _state.sent();
-                    expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
-                    expect(condition).toHaveBeenCalledTimes(3);
-                    return [
-                        2
-                    ];
-            }
-        });
-    }));
+    it('should not retry on success', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runner, call, res, ret;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(1, condition);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: true
+                        });
+                        res = runner.transform(call);
+                        expect(condition).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        ret = _state.sent();
+                        expect(ret).toEqual({
+                            text: 'test',
+                            ok: true
+                        });
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should not retry if refused by the condition', function() {
+        return _async_to_generator(function() {
+            var conditionFalsy, plugin, runner, call, res;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        conditionFalsy = jest.fn().mockReturnValue(false);
+                        plugin = new RetryFetch(3, conditionFalsy);
+                        runner = plugin.load({
+                            url: 'http://www.test.com',
+                            fetchPlugins: []
+                        });
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false,
+                            clone: function() {
+                                return {};
+                            }
+                        });
+                        res = runner.transform(call);
+                        return [
+                            4,
+                            res
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(conditionFalsy).toHaveBeenCalledTimes(1);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(2, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on fetch rejection with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new RetryFetch(2, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.reject(new Error(JSON.stringify({
+                            text: 'test',
+                            ok: true
+                        })));
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(2);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call', function() {
+        return _async_to_generator(function() {
+            var condition, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        plugin = new RetryFetch(3, condition);
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.runAllTimersAsync()
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    it('should retry on not ok call with wait', function() {
+        return _async_to_generator(function() {
+            var condition, delay, plugin, runners, runner, call, callback;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        condition = jest.fn().mockReturnValue(true);
+                        delay = 500;
+                        plugin = new RetryFetch(3, condition, function() {
+                            return delay;
+                        });
+                        runners = [];
+                        runner = plugin.load({
+                            url: 'not an url',
+                            fetchPlugins: runners
+                        });
+                        runners.push(runner);
+                        call = Promise.resolve({
+                            text: 'test',
+                            ok: false
+                        });
+                        callback = jest.fn();
+                        runner.transform(call).catch(callback);
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(2 * delay)
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(callback).not.toHaveBeenCalled();
+                        return [
+                            4,
+                            jest.advanceTimersByTimeAsync(delay)
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(callback).toHaveBeenCalledWith(expect.objectContaining({}));
+                        expect(condition).toHaveBeenCalledTimes(3);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 });