@dhis2/app-service-offline 3.11.3 → 3.12.0-alpha.1

package/build/cjs/lib/__tests__/network-status.test.js

@@ -1,21 +1,14 @@
 "use strict";
 
 var _react = require("@testing-library/react");
-
-var _reactHooks = require("@testing-library/react-hooks");
-
 var _react2 = _interopRequireDefault(require("react"));
-
 var _networkStatus = require("../network-status");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function wait(ms) {
   return new Promise(resolve => {
     setTimeout(() => resolve(), ms);
   });
 }
-
 beforeEach(() => {
   jest.restoreAllMocks();
 });
@@ -27,7 +20,7 @@ describe('initalizes to navigator.onLine value', () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
+    } = (0, _react.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
     expect(result.current.online).toBe(true);
     expect(result.current.offline).toBe(false);
   });
@@ -35,61 +28,59 @@ describe('initalizes to navigator.onLine value', () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(false);
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
+    } = (0, _react.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
     expect(result.current.online).toBe(false);
     expect(result.current.offline).toBe(true);
   });
 });
 describe('state changes in response to browser "online" and "offline" events', () => {
   it('switches from online to offline when the "offline" event triggers', async () => {
-    jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true); // Capture callback to trigger later using addEventListener mock
-
+    jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
+    // Capture callback to trigger later using addEventListener mock
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 50
       }
     });
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       // Trigger callback captured by addEventListener mock
       events.offline(new Event('offline'));
-    }); // Wait for debounce
+    });
 
-    await waitForNextUpdate({
-      timeout: 60
+    // Wait for debounce
+    await (0, _react.waitFor)(() => {
+      expect(result.current.online).toBe(false);
+      expect(result.current.offline).toBe(true);
     });
-    expect(result.current.online).toBe(false);
-    expect(result.current.offline).toBe(true);
   });
   it('switches from offline to online when the "online" event triggers', async () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(false);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 50
       }
     });
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.online(new Event('online'));
-    }); // Wait for debounce
+    });
 
-    await waitForNextUpdate({
-      timeout: 60
+    // Wait for debounce
+    await (0, _react.waitFor)(() => {
+      expect(result.current.online).toBe(true);
+      expect(result.current.offline).toBe(false);
     });
-    expect(result.current.online).toBe(true);
-    expect(result.current.offline).toBe(false);
   });
 });
 describe('debouncing state changes', () => {
@@ -99,22 +90,22 @@ describe('debouncing state changes', () => {
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
-    await (0, _reactHooks.act)(async () => {
+      result
+    } = (0, _react.renderHook)(() => (0, _networkStatus.useNetworkStatus)());
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // Immediately, nothing should happen
-
-    expect(result.current.online).toBe(true); // 1s later, final 'offline' event should resolve
+    });
 
-    await waitForNextUpdate({
-      timeout: 1009
+    // Immediately, nothing should happen
+    expect(result.current.online).toBe(true);
+    await wait(1000);
+    // 1s later, final 'offline' event should resolve
+    await (0, _react.waitFor)(() => {
+      expect(result.current.online).toBe(false);
     });
-    expect(result.current.online).toBe(false);
   });
   it('can have debounce delay set to another number', async () => {
     // Start online
@@ -122,55 +113,54 @@ describe('debouncing state changes', () => {
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 50
       }
     });
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // Immediately, nothing should happen
+    });
 
-    expect(result.current.online).toBe(true); // 50ms later, final "offline" event should finally resolve
+    // Immediately, nothing should happen
+    expect(result.current.online).toBe(true);
 
-    await waitForNextUpdate({
-      timeout: 60
+    // 50ms later, final "offline" event should finally resolve
+    await (0, _react.waitFor)(() => {
+      expect(result.current.online).toBe(false);
     });
-    expect(result.current.online).toBe(false);
   });
   it('can use a debounceDelay of 0 to skip debouncing', async () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 0
       }
     });
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // await wait(0) didn't work here
-
-    await waitForNextUpdate({
-      timeout: 0
-    }); // There should be no delay before status is offline
+    });
 
-    expect(result.current.online).toBe(false);
-    expect(result.current.offline).toBe(true);
+    // await wait(0) didn't work here
+    await (0, _react.waitFor)(() => {
+      // There should be no delay before status is offline
+      expect(result.current.online).toBe(false);
+      expect(result.current.offline).toBe(true);
+    });
   });
   it('can have the debounce delay changed during its lifecycle', async () => {
     // Start with 150 ms debounce
@@ -179,51 +169,50 @@ describe('debouncing state changes', () => {
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
       result,
-      waitForNextUpdate,
       rerender
-    } = (0, _reactHooks.renderHook)(function () {
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 150
       }
     });
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // Immediately, nothing should happen
+    });
 
-    expect(result.current.online).toBe(true); // 150ms later, final "offline" event should finally resolve
+    // Immediately, nothing should happen
+    expect(result.current.online).toBe(true);
 
-    await waitForNextUpdate({
-      timeout: 160
-    });
-    expect(result.current.online).toBe(false); // Change to 50 ms debounce
+    // 150ms later, final "offline" event should finally resolve
+    await wait(160);
+    expect(result.current.online).toBe(false);
 
+    // Change to 50 ms debounce
     rerender({
       debounceDelay: 50
     });
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.online(new Event('online'));
       events.offline(new Event('offline'));
       events.online(new Event('online'));
-    }); // Immediately, nothing should happen
+    });
 
-    expect(result.current.online).toBe(false); // 50ms later, final "online" event should finally resolve
+    // Immediately, nothing should happen
+    expect(result.current.online).toBe(false);
 
-    await waitForNextUpdate({
-      timeout: 60
-    });
+    // 50ms later, final "online" event should finally resolve
+    await wait(60);
     expect(result.current.online).toBe(true);
   });
   it('handles debounced state change when parent component rerenders during a debounce delay', async () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
-
     const TestComponent = () => {
       const {
         online
@@ -234,33 +223,34 @@ describe('debouncing state changes', () => {
         "data-testid": "status"
       }, online ? 'on' : 'off');
     };
-
     const {
       rerender
-    } = (0, _react.render)( /*#__PURE__*/_react2.default.createElement(TestComponent, null));
+    } = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(TestComponent, null));
     const {
       getByTestId
     } = _react.screen;
     expect(getByTestId('status')).toHaveTextContent('on');
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // Immediately, nothing should happen
+    });
 
-    expect(getByTestId('status')).toHaveTextContent('on'); // Rerender parent component
+    // Immediately, nothing should happen
+    expect(getByTestId('status')).toHaveTextContent('on');
 
-    rerender( /*#__PURE__*/_react2.default.createElement(TestComponent, null)); // Final "offline" event should still resolve
+    // Rerender parent component
+    rerender(/*#__PURE__*/_react2.default.createElement(TestComponent, null));
 
+    // Final "offline" event should still resolve
     await (0, _react.waitFor)(() => expect(getByTestId('status')).toHaveTextContent('off'));
   });
   it('handles debounced state change when debounce delay is changed during a delay', async () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
-
-    const TestComponent = (_ref) => {
+    const TestComponent = _ref => {
       let {
         options
       } = _ref;
@@ -271,10 +261,9 @@ describe('debouncing state changes', () => {
         "data-testid": "status"
       }, online ? 'on' : 'off');
     };
-
     const {
       rerender
-    } = (0, _react.render)( /*#__PURE__*/_react2.default.createElement(TestComponent, {
+    } = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(TestComponent, {
       options: {
         debounceDelay: 100
       }
@@ -283,28 +272,30 @@ describe('debouncing state changes', () => {
       getByTestId
     } = _react.screen;
     expect(getByTestId('status')).toHaveTextContent('on');
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // Immediately, nothing should happen
+    });
 
-    expect(getByTestId('status')).toHaveTextContent('on'); // Change debounce options
+    // Immediately, nothing should happen
+    expect(getByTestId('status')).toHaveTextContent('on');
 
-    rerender( /*#__PURE__*/_react2.default.createElement(TestComponent, {
+    // Change debounce options
+    rerender(/*#__PURE__*/_react2.default.createElement(TestComponent, {
       options: {
         debounceDelay: 50
       }
-    })); // Final "offline" event should still resolve
+    }));
 
+    // Final "offline" event should still resolve
     await (0, _react.waitFor)(() => expect(getByTestId('status')).toHaveTextContent('off'));
   });
   it('debounces consistently across rerenders', async () => {
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
-
     const TestComponent = () => {
       const {
         online
@@ -315,35 +306,39 @@ describe('debouncing state changes', () => {
         "data-testid": "status"
       }, online ? 'on' : 'off');
     };
-
     const {
       rerender
-    } = (0, _react.render)( /*#__PURE__*/_react2.default.createElement(TestComponent, null));
+    } = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(TestComponent, null));
     const {
       getByTestId
     } = _react.screen;
     expect(getByTestId('status')).toHaveTextContent('on');
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       // Multiple events in succession
       events.offline(new Event('offline'));
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // wait a little bit - not long enough for debounce to resolve
+    });
 
+    // wait a little bit - not long enough for debounce to resolve
     await wait(50);
-    expect(getByTestId('status')).toHaveTextContent('on'); // Rerender parent component
+    expect(getByTestId('status')).toHaveTextContent('on');
 
-    rerender( /*#__PURE__*/_react2.default.createElement(TestComponent, null)); // Trigger more events
+    // Rerender parent component
+    rerender(/*#__PURE__*/_react2.default.createElement(TestComponent, null));
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger more events
+    await (0, _react.act)(async () => {
       events.online(new Event('online'));
       events.offline(new Event('offline'));
-    }); // wait a little more - long enough that the first debounced callbacks
-    // _would_ have resolved if there weren't the second set of events
+    });
 
+    // wait a little more - long enough that the first debounced callbacks
+    // _would_ have resolved if there weren't the second set of events
     await wait(60);
-    expect(getByTestId('status')).toHaveTextContent('on'); // wait long enough for second set of callbacks to resolve
+    expect(getByTestId('status')).toHaveTextContent('on');
 
+    // wait long enough for second set of callbacks to resolve
     await (0, _react.waitFor)(() => expect(getByTestId('status')).toHaveTextContent('off'));
   });
 });
@@ -352,49 +347,48 @@ describe('it updates the lastOnline value in local storage', () => {
   const testDateString = 'Fri, 27 Aug 2021 19:53:06 GMT';
   it('sets lastOnline in local storage when it goes offline', async () => {
     var _result$current$lastO;
-
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 0
       }
-    }); // Correct initial state
+    });
 
+    // Correct initial state
     expect(localStorage.getItem(lastOnlineKey)).toBe(null);
     expect(result.current.lastOnline).toBe(null);
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.offline(new Event('offline'));
-    }); // Wait for debounce
-
-    await waitForNextUpdate({
-      timeout: 0
     });
+
+    // Wait for debounce
+    await wait(500);
     expect(result.current.online).toBe(false);
-    expect(result.current.offline).toBe(true); // Check localStorage for a stored date
+    expect(result.current.offline).toBe(true);
 
+    // Check localStorage for a stored date
     const parsedDate = new Date(localStorage.getItem(lastOnlineKey));
-    expect(parsedDate.toString()).not.toBe('Invalid Date'); // Check hook return value
-
+    expect(parsedDate.toString()).not.toBe('Invalid Date');
+    // Check hook return value
     expect(result.current.lastOnline).toBeInstanceOf(Date);
     expect((_result$current$lastO = result.current.lastOnline) === null || _result$current$lastO === void 0 ? void 0 : _result$current$lastO.toUTCString()).toBe(localStorage.getItem(lastOnlineKey));
-  }); // not necessary
+  });
 
+  // not necessary
   it.skip("sets lastOnline on mount if it's not set", () => {
     var _result$current$lastO2;
-
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(false);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
       result
-    } = (0, _reactHooks.renderHook)(function () {
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
@@ -414,7 +408,7 @@ describe('it updates the lastOnline value in local storage', () => {
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
       result
-    } = (0, _reactHooks.renderHook)(function () {
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
@@ -423,7 +417,7 @@ describe('it updates the lastOnline value in local storage', () => {
     });
     expect(localStorage.getItem(lastOnlineKey)).toBe(testDateString);
     expect(result.current.lastOnline).toEqual(new Date(testDateString));
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.offline(new Event('offline'));
     });
     await wait(0);
@@ -439,9 +433,8 @@ describe('it updates the lastOnline value in local storage', () => {
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
@@ -450,60 +443,54 @@ describe('it updates the lastOnline value in local storage', () => {
     });
     expect(localStorage.getItem(lastOnlineKey)).toBe(testDateString);
     expect(result.current.lastOnline).toEqual(new Date(testDateString));
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.offline(new Event('online'));
-    }); // Wait for debounce
-
-    await waitForNextUpdate({
-      timeout: 0
     });
+
+    // Wait for debounce
+    await wait(500);
     expect(result.current.online).toBe(true);
-    expect(result.current.offline).toBe(false); // expect(localStorage.getItem(lastOnlineKey)).toBe(null)
+    expect(result.current.offline).toBe(false);
 
+    // expect(localStorage.getItem(lastOnlineKey)).toBe(null)
     expect(result.current.lastOnline).toBe(null);
   });
   it('tracks correctly when going offline and online', async () => {
     var _result$current$lastO3, _result$current$lastO4;
-
     jest.spyOn(navigator, 'onLine', 'get').mockReturnValueOnce(true);
     const events = {};
     window.addEventListener = jest.fn((event, cb) => events[event] = cb);
     const {
-      result,
-      waitForNextUpdate
-    } = (0, _reactHooks.renderHook)(function () {
+      result
+    } = (0, _react.renderHook)(function () {
       return (0, _networkStatus.useNetworkStatus)(...arguments);
     }, {
       initialProps: {
         debounceDelay: 0
       }
-    }); // Correct initial state
+    });
 
+    // Correct initial state
     expect(localStorage.getItem(lastOnlineKey)).toBe(null);
     expect(result.current.lastOnline).toBe(null);
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.offline(new Event('offline'));
     });
-    await waitForNextUpdate({
-      timeout: 0
-    });
+    await (0, _react.waitFor)(() => undefined);
     const firstDate = new Date(localStorage.getItem(lastOnlineKey));
     const firstValue = (_result$current$lastO3 = result.current.lastOnline) === null || _result$current$lastO3 === void 0 ? void 0 : _result$current$lastO3.valueOf();
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       events.offline(new Event('online'));
     });
-    await waitForNextUpdate({
-      timeout: 0
-    });
-    expect(result.current.lastOnline).toBe(null); // todo: this is an error from UTC strings' imprecision
+    await wait(500);
+    expect(result.current.lastOnline).toBe(null);
 
-    await wait(1000);
-    (0, _reactHooks.act)(() => {
+    // todo: this is an error from UTC strings' imprecision
+    await wait(500);
+    (0, _react.act)(() => {
       events.offline(new Event('offline'));
     });
-    await waitForNextUpdate({
-      timeout: 0
-    });
+    await wait(500);
     expect(new Date(localStorage.getItem(lastOnlineKey))).not.toEqual(firstDate);
     expect((_result$current$lastO4 = result.current.lastOnline) === null || _result$current$lastO4 === void 0 ? void 0 : _result$current$lastO4.valueOf()).not.toEqual(firstValue);
   });