@wise/dynamic-flow-client 3.5.0-experimental-6654c72 → 3.5.0-experimental-63c768d

package/build/legacy/common/hooks/useExternal/useExternal.spec.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        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, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import DynamicFlow from '../../../dynamicFlow/DynamicFlow';
+import { renderWithProviders } from '../../../test-utils';
+import { getMockHttpClient, respondWith } from '../../../../test-utils';
+var mockWindowOpenSuccess = function () {
+    return window.open.mockImplementation(function () { return 'fake window'; });
+};
+var mockWindonOpenFail = function () { return window.open.mockImplementation(function () { return null; }); };
+describe('useExternal', function () {
+    var mockHttpClient = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, Promise.resolve(new Response(''))];
+    }); }); });
+    var onError = jest.fn();
+    var onCompletion = jest.fn();
+    var renderComponent = function (step) {
+        return renderWithProviders(_jsx(DynamicFlow, { flowId: "the-flow-id", initialStep: step, httpClient: mockHttpClient, onCompletion: onCompletion, onError: onError }));
+    };
+    afterEach(function () {
+        mockHttpClient.mockClear();
+        jest.restoreAllMocks();
+    });
+    describe('Given a step with an "external" property', function () {
+        var step = {
+            type: 'form',
+            id: 'external',
+            title: 'Step Title',
+            external: { url: 'https://third-party.website' },
+            layout: [{ type: 'paragraph', text: 'This is a paragraph in the step layout' }],
+            schemas: []
+        };
+        it('attempts to open the specified URL, but ONLY ONCE', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(window, 'open');
+                        mockWindowOpenSuccess();
+                        renderComponent(step);
+                        expect(window.open).toHaveBeenCalledTimes(1);
+                        expect(window.open).toHaveBeenCalledWith('https://third-party.website', '_blank');
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(window.open).toHaveBeenCalledTimes(1);
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        describe('when the window/tab fails to open', function () {
+            it('displays a confirmation UI (ExternalConfirmationStep)', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            jest.spyOn(window, 'open');
+                            mockWindonOpenFail();
+                            renderComponent(step);
+                            return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            describe('when the confirmation button is clicked', function () {
+                it('opens the external url and displays the step layout', function () {
+                    jest.spyOn(window, 'open');
+                    mockWindonOpenFail();
+                    renderComponent(step);
+                    expect(screen.getByText('Please confirm')).toBeInTheDocument();
+                    var confirmButton = screen.getByText('Open in new tab');
+                    window.open.mockClear();
+                    fireEvent.click(confirmButton);
+                    expect(window.open).toHaveBeenCalledTimes(1);
+                    expect(screen.getByText('This is a paragraph in the step layout')).toBeInTheDocument();
+                });
+            });
+            describe('when the cancel button is clicked', function () {
+                it('does not open the external url and displays the step layout', function () {
+                    jest.spyOn(window, 'open');
+                    mockWindonOpenFail();
+                    renderComponent(step);
+                    expect(screen.getByText('Please confirm')).toBeInTheDocument();
+                    var confirmButton = screen.getByText('Cancel');
+                    window.open.mockClear();
+                    fireEvent.click(confirmButton);
+                    expect(window.open).toHaveBeenCalledTimes(0);
+                    expect(screen.getByText('This is a paragraph in the step layout')).toBeInTheDocument();
+                });
+            });
+            describe('when a subsequent step with external is loaded using the same URL', function () {
+                var mockClient = getMockHttpClient({
+                    '/external': function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, respondWith({
+                                    type: 'form',
+                                    id: 'external',
+                                    title: 'External Step',
+                                    external: { url: 'https://third-party.website' },
+                                    layout: [
+                                        { type: 'paragraph', text: 'This is a paragraph in the external step layout' },
+                                        { type: 'button', action: { url: '/layout', title: 'Continue to layout step' } },
+                                    ],
+                                    schemas: []
+                                })];
+                        });
+                    }); },
+                    '/layout': function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, respondWith({
+                                    type: 'form',
+                                    id: 'layout',
+                                    title: 'Layout Step',
+                                    layout: [
+                                        { type: 'paragraph', text: 'This is a paragraph in the layout step layout' },
+                                        {
+                                            type: 'button',
+                                            action: { url: '/external', title: 'Continue to external step' }
+                                        },
+                                    ],
+                                    schemas: []
+                                })];
+                        });
+                    }); }
+                });
+                it('displays the confirmation UI (ExternalConfirmationStep) a second time', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var confirmButton;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                jest.spyOn(window, 'open');
+                                mockWindonOpenFail();
+                                renderWithProviders(_jsx(DynamicFlow, { flowId: "the-flow-id", initialAction: { method: 'GET', url: '/external' }, httpClient: mockClient, onCompletion: onCompletion, onError: onError }));
+                                return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                            case 1:
+                                _a.sent();
+                                confirmButton = screen.getByText('Cancel');
+                                window.open.mockClear();
+                                fireEvent.click(confirmButton);
+                                expect(window.open).toHaveBeenCalledTimes(0);
+                                expect(screen.getByText('This is a paragraph in the external step layout')).toBeInTheDocument();
+                                fireEvent.click(screen.getByText(/continue to layout step/i));
+                                return [4 /*yield*/, expect(screen.findByText('Layout Step')).resolves.toBeInTheDocument()];
+                            case 2:
+                                _a.sent();
+                                fireEvent.click(screen.getByText(/continue to external step/i));
+                                return [4 /*yield*/, expect(screen.findByText('Please confirm')).resolves.toBeInTheDocument()];
+                            case 3:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('when the window/tab opens successfully', function () {
+            it('displays the step normally', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            jest.spyOn(window, 'open');
+                            mockWindowOpenSuccess();
+                            renderComponent(step);
+                            return [4 /*yield*/, expect(screen.findByText('This is a paragraph in the step layout')).resolves.toBeInTheDocument()];
+                        case 1:
+                            _a.sent();
+                            expect(screen.queryByText('Please confirm')).not.toBeInTheDocument();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+    describe('Given a step with a malformed "external" property', function () {
+        var step = {
+            type: 'form',
+            id: 'external',
+            title: 'Step Title',
+            external: { wrong: 'banana' },
+            layout: [{ type: 'paragraph', text: 'This is a paragraph in the step layout' }],
+            schemas: []
+        };
+        it('does not attempt to open a new tab', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(window, 'open');
+                        mockWindowOpenSuccess();
+                        renderComponent(step);
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(window.open).not.toHaveBeenCalled();
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/build/legacy/common/hooks/useStepPolling/useStepPolling.spec.js

@@ -0,0 +1,288 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        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, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/require-await */
+import { render, waitFor } from '@testing-library/react';
+import DynamicFlow from '../../../dynamicFlow/DynamicFlow';
+import { TestContextProviders } from '../../../test-utils';
+describe('useStepPolling', function () {
+    var mockHttpClient = jest.fn(function (input, init) { return Promise.resolve(new Response('')); });
+    var onError = jest.fn();
+    var onCompletion = jest.fn();
+    function renderComponent(step) {
+        render(_jsx(TestContextProviders, { children: _jsx(DynamicFlow, { flowId: "the-flow-id", initialStep: step, httpClient: mockHttpClient, onCompletion: onCompletion, onError: onError }) }));
+    }
+    beforeEach(function () {
+        jest.useFakeTimers();
+    });
+    afterEach(function () {
+        mockHttpClient.mockClear();
+        onError.mockClear();
+        onCompletion.mockClear();
+        jest.restoreAllMocks();
+        jest.useRealTimers();
+    });
+    var FIVE_SECS = 5 * 1000;
+    var MAX_ATTEMPTS = 5;
+    describe('Given a step with a polling property', function () {
+        var POLLING_URL = 'https://our-polling-url/';
+        var step = {
+            type: 'form',
+            polling: {
+                url: POLLING_URL,
+                interval: 5,
+                maxAttempts: MAX_ATTEMPTS,
+                onError: { action: { url: '/on-error' } }
+            }
+        };
+        it('makes a requests to the speficied URL with the given interval', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                renderComponent(step);
+                jest.advanceTimersByTime(FIVE_SECS / 2);
+                expect(mockHttpClient).not.toHaveBeenCalled();
+                jest.advanceTimersByTime(FIVE_SECS / 2);
+                expect(mockHttpClient).toHaveBeenLastCalledWith(POLLING_URL);
+                return [2 /*return*/];
+            });
+        }); });
+        describe('when the polling response contains an action', function () {
+            describe('a submitting action', function () {
+                it('executes the action, loading a new step, and stops polling', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                renderComponent(step);
+                                mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        return [2 /*return*/, input === POLLING_URL
+                                                ? new Response(JSON.stringify({
+                                                    action: {
+                                                        url: '/success',
+                                                        method: 'POST',
+                                                        data: { 'action-data': '1234567890' }
+                                                    }
+                                                }))
+                                                : new Response("{}")];
+                                    });
+                                }); });
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(mockHttpClient).toHaveBeenLastCalledWith('/success', expect.objectContaining({ body: "{\"action-data\":\"1234567890\"}" }));
+                                    })];
+                            case 1:
+                                _a.sent();
+                                // Stops polling
+                                mockHttpClient.mockClear();
+                                jest.advanceTimersByTime(FIVE_SECS * 2);
+                                expect(mockHttpClient).not.toHaveBeenCalled();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            describe('an exit action', function () {
+                it('executes the action, exiting the flow, and stops polling', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                renderComponent(step);
+                                mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        return [2 /*return*/, input === POLLING_URL
+                                                ? new Response("{\"action\":{\"exit\":true,\"result\":{\"action-result\":\"0987654321\"}}}")
+                                                : new Response("{}")];
+                                    });
+                                }); });
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                expect(mockHttpClient).toHaveBeenLastCalledWith(POLLING_URL);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(onCompletion).toHaveBeenLastCalledWith({ 'action-result': '0987654321' });
+                                    })];
+                            case 1:
+                                _a.sent();
+                                // Stops polling
+                                mockHttpClient.mockClear();
+                                jest.advanceTimersByTime(FIVE_SECS * 2);
+                                expect(mockHttpClient).not.toHaveBeenCalled();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            }); //
+        });
+        describe("when the polling response doesn't contain an action", function () {
+            describe("...temporarily", function () {
+                it('continues polling until the response contains an action', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                renderComponent(step);
+                                mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        return [2 /*return*/, input === POLLING_URL
+                                                ? new Response('please wait...', { status: 202 })
+                                                : new Response("{}")];
+                                    });
+                                }); });
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(mockHttpClient).toHaveBeenCalledTimes(1);
+                                    })];
+                            case 1:
+                                _a.sent();
+                                expect(mockHttpClient).toHaveBeenLastCalledWith(POLLING_URL);
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(mockHttpClient).toHaveBeenCalledTimes(2);
+                                    })];
+                            case 2:
+                                _a.sent();
+                                expect(mockHttpClient).toHaveBeenLastCalledWith(POLLING_URL);
+                                mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        return [2 /*return*/, input === POLLING_URL
+                                                ? new Response("{\"action\":{\"url\":\"/success\",\"data\":{\"action-data\":\"1234567890\"}}}")
+                                                : new Response("{}")];
+                                    });
+                                }); });
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(mockHttpClient).toHaveBeenLastCalledWith('/success', expect.objectContaining({ body: "{\"action-data\":\"1234567890\"}" }));
+                                    })];
+                            case 3:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+            describe("...permanently", function () {
+                it('continues polling until maxAttempts is reached, then onError.action is triggered', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var _loop_1, i;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                renderComponent(step);
+                                mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        return [2 /*return*/, input === POLLING_URL
+                                                ? new Response('this will never change', { status: 202 })
+                                                : new Response("{}")];
+                                    });
+                                }); });
+                                _loop_1 = function (i) {
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
+                                            case 0:
+                                                jest.advanceTimersByTime(FIVE_SECS);
+                                                return [4 /*yield*/, waitFor(function () {
+                                                        expect(mockHttpClient).toHaveBeenCalledTimes(i + 1);
+                                                        // eslint-disable-next-line testing-library/no-wait-for-multiple-assertions
+                                                        expect(mockHttpClient).toHaveBeenLastCalledWith(POLLING_URL);
+                                                    })];
+                                            case 1:
+                                                _b.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                };
+                                i = 0;
+                                _a.label = 1;
+                            case 1:
+                                if (!(i < MAX_ATTEMPTS)) return [3 /*break*/, 4];
+                                return [5 /*yield**/, _loop_1(i)];
+                            case 2:
+                                _a.sent();
+                                _a.label = 3;
+                            case 3:
+                                i++;
+                                return [3 /*break*/, 1];
+                            case 4:
+                                jest.advanceTimersByTime(FIVE_SECS);
+                                return [4 /*yield*/, waitFor(function () {
+                                        expect(mockHttpClient).toHaveBeenLastCalledWith('/on-error', expect.anything());
+                                    })];
+                            case 5:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+            });
+        });
+        describe('when the polling response contains an error status code', function () {
+            it('executes the onError.action', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            renderComponent(step);
+                            mockHttpClient.mockImplementation(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, new Response(null, { status: 400 })];
+                            }); }); });
+                            jest.advanceTimersByTime(FIVE_SECS);
+                            return [4 /*yield*/, waitFor(function () {
+                                    expect(mockHttpClient).toHaveBeenLastCalledWith('/on-error', expect.anything());
+                                })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+        describe('when the polling request fails', function () {
+            it('executes the onError.action', function () { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            renderComponent(step);
+                            mockHttpClient.mockImplementation(function (input) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, input === POLLING_URL ? new Response("{}", { status: 500 }) : new Response("{}")];
+                            }); }); });
+                            jest.advanceTimersByTime(FIVE_SECS);
+                            return [4 /*yield*/, waitFor(function () {
+                                    expect(mockHttpClient).toHaveBeenLastCalledWith('/on-error', expect.anything());
+                                })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
+    });
+});

package/build/legacy/common/utils/debounce.spec.js

@@ -0,0 +1,72 @@
+import { debounce } from './debounce';
+describe('debounce', function () {
+    beforeAll(function () {
+        jest.useFakeTimers();
+    });
+    afterAll(function () {
+        jest.useRealTimers();
+    });
+    it('will delay function execution until the wait period has passed', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        expect(fn).toHaveBeenCalledTimes(0);
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('will call function with provided arguments', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn('a', 'b', 'c');
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will reset the wait period and ignore previous executions if called within the wait period', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn(1, 2, 3);
+        jest.advanceTimersByTime(4);
+        debouncedFn('a', 'b', 'c');
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will call the same function twice if invoked after the wait period', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    describe('flush', function () {
+        it('will call the callback immediately', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('uses the last passed args', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn(1, 2, 3);
+            debouncedFn('a', 'b', 'c');
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+            expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+        });
+    });
+    describe('cancel', function () {
+        it('cancels any waiting callback', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.cancel();
+            jest.advanceTimersByTime(5);
+            expect(fn).toHaveBeenCalledTimes(0);
+        });
+    });
+});

package/build/legacy/common/utils/file-utils.spec.js

@@ -0,0 +1,69 @@
+import { Status } from '@transferwise/components';
+import { areFilesSame } from './file-utils';
+var constructFile = function (_a) {
+    var _b = _a.id, id = _b === void 0 ? 123 : _b, _c = _a.status, status = _c === void 0 ? Status.SUCCEEDED : _c;
+    return ({ id: id, status: status });
+};
+describe('Given a set of utility functions for file', function () {
+    describe('when checking if two lists of files are same', function () {
+        it('should return true if empty file list is compared', function () {
+            expect(areFilesSame([], [])).toBeTruthy();
+        });
+        it('should return false comparing file with different ids', function () {
+            var file = constructFile({ id: 123 });
+            var anotherFile = constructFile({ id: 234 });
+            expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+        });
+        it('should return true comparing file with same ids', function () {
+            var file = constructFile({ id: 123 });
+            var anotherFile = constructFile({ id: 123 });
+            expect(areFilesSame([anotherFile], [file])).toBeTruthy();
+        });
+        it('should return false comparing file with same ids but different status', function () {
+            var anotherFile = constructFile({ id: 123, status: Status.FAILED });
+            var file = constructFile({ id: 123, status: Status.SUCCEEDED });
+            expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+        });
+        it('should return false comparing respective file ids with their status status', function () {
+            var fileUpdate1 = constructFile({ id: 111, status: Status.FAILED });
+            var fileUpdate2 = constructFile({ id: 222, status: Status.SUCCEEDED });
+            var fileUpdate3 = constructFile({ id: 333, status: Status.SUCCEEDED });
+            var file1 = constructFile({ id: 111, status: Status.PENDING });
+            var file2 = constructFile({ id: 222, status: Status.SUCCEEDED });
+            var file3 = constructFile({ id: 333, status: Status.SUCCEEDED });
+            expect(areFilesSame([fileUpdate1, fileUpdate2, fileUpdate3], [file1, file2, file3])).toBeFalsy();
+        });
+        describe('should only consider id and status in similarity comparison', function () {
+            it('when files are same', function () {
+                var anotherFile = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename1.png'
+                };
+                var file = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.somethingElse.com/file.png',
+                    filename: 'filename2.png'
+                };
+                expect(areFilesSame([anotherFile], [file])).toBeTruthy();
+            });
+            it('when files are different', function () {
+                var anotherFile = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename.png'
+                };
+                var file = {
+                    id: 112,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename.png'
+                };
+                expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+            });
+        });
+    });
+});