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

package/build/cjs/lib/dhis2-connection-status/dhis2-connection-status.test.js

@@ -1,49 +1,41 @@
 "use strict";
 
 var _appServiceConfig = require("@dhis2/app-service-config");
-
-var _reactHooks = require("@testing-library/react-hooks");
-
-var _react = _interopRequireDefault(require("react"));
-
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
 var _testMocks = require("../../utils/test-mocks");
-
 var _offlineProvider = require("../offline-provider");
-
 var _dhis2ConnectionStatus = require("./dhis2-connection-status");
-
 var _smartInterval = require("./smart-interval");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 
 // important that this name starts with 'mock' to be hoisted correctly
 const mockPing = jest.fn().mockImplementation(() => Promise.resolve());
 jest.mock('./use-ping-query.ts', () => ({
   usePingQuery: () => mockPing
 }));
-
 const failedPing = () => Promise.reject({
   message: 'this is a network error',
   type: 'network'
 });
-
 const FIRST_INTERVAL_MS = _smartInterval.DEFAULT_INITIAL_DELAY_MS;
 const SECOND_INTERVAL_MS = FIRST_INTERVAL_MS * _smartInterval.DEFAULT_INCREMENT_FACTOR;
 const THIRD_INTERVAL_MS = SECOND_INTERVAL_MS * _smartInterval.DEFAULT_INCREMENT_FACTOR;
-const FOURTH_INTERVAL_MS = THIRD_INTERVAL_MS * _smartInterval.DEFAULT_INCREMENT_FACTOR; // Explanation: The length of the Nth interval is:
+const FOURTH_INTERVAL_MS = THIRD_INTERVAL_MS * _smartInterval.DEFAULT_INCREMENT_FACTOR;
+
+// Explanation: The length of the Nth interval is:
 // initialDelay * incrementFactor ^ (N - 1)
 // Using some algebra and the law of logs, the Nth interval
 // which is longer than the max delay is:
 // N >= (ln (maxDelay / initialDelay) / ln (incrementFactor)) + 1
 // => then use Math.ceil to handle the 'greater than' effect
-
 const INTERVALS_TO_REACH_MAX_DELAY = Math.ceil(Math.log(_smartInterval.DEFAULT_MAX_DELAY_MS / _smartInterval.DEFAULT_INITIAL_DELAY_MS) / Math.log(_smartInterval.DEFAULT_INCREMENT_FACTOR) + 1);
-
-const wrapper = (_ref) => {
+const wrapper = _ref => {
   let {
     children
   } = _ref;
-  return /*#__PURE__*/_react.default.createElement(_appServiceConfig.ConfigProvider, {
+  return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
     config: {
       baseUrl: '..',
       apiVersion: 42,
@@ -55,10 +47,11 @@ const wrapper = (_ref) => {
         full: 'n/a'
       }
     }
-  }, /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+  }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
     offlineInterface: _testMocks.mockOfflineInterface
   }, children));
 };
+
 /**
  * Assert on the delay of the last time setTimeoutSpy was called with
  * the `callbackAndRestart()` function in smartInterval.
@@ -68,11 +61,8 @@ const wrapper = (_ref) => {
  * an assertion like:
  * `expect(setTimeoutSpy).toHaveBeenLastCalledWith(..., expectedDelay)`
  */
-
-
 const assertLastDelay = (setTimeoutSpy, expectedDelay) => {
   const calls = setTimeoutSpy.mock.calls;
-
   for (let i = calls.length - 1; i >= 0; i--) {
     if (calls[i][0].name === 'callbackAndRestart') {
       expect(calls[i][1]).toBe(expectedDelay);
@@ -80,7 +70,6 @@ const assertLastDelay = (setTimeoutSpy, expectedDelay) => {
     }
   }
 };
-
 const testCurrentDate = new Date('Fri, 03 Feb 2023 13:52:31 GMT');
 beforeAll(() => {
   jest.useFakeTimers();
@@ -92,8 +81,8 @@ beforeEach(() => {
   jest.spyOn(document, 'hasFocus').mockReturnValue(true);
 });
 afterEach(() => {
-  jest.clearAllMocks(); // for lastConnected:
-
+  jest.clearAllMocks();
+  // for lastConnected:
   localStorage.clear();
 });
 afterAll(() => {
@@ -104,7 +93,7 @@ describe('initialization to the right values based on offline interface', () =>
   test('when latestIsConnected is true', () => {
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
     });
     expect(result.current.isConnected).toBe(true);
@@ -112,54 +101,53 @@ describe('initialization to the right values based on offline interface', () =>
     expect(result.current.lastConnected).toBe(null);
   });
   test('when latestIsConnected is false', () => {
-    const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    const customMockOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref2) => {
+    const customWrapper = _ref2 => {
       let {
         children
       } = _ref2;
-      return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+      return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
         offlineInterface: customMockOfflineInterface
       }, children);
     };
-
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: customWrapper
     });
     expect(result.current.isConnected).toBe(false);
-    expect(result.current.isDisconnected).toBe(true); // If localStorage is clear, sets 'lastConnected' to `now` as a best
+    expect(result.current.isDisconnected).toBe(true);
+    // If localStorage is clear, sets 'lastConnected' to `now` as a best
     // effort to provide useful information.
     // There will be more detailed testing of lastConnected below
-
     expect(result.current.lastConnected).toEqual(testCurrentDate);
-  }); // This might happen in the unlikely circumstance that the provider
+  });
+
+  // This might happen in the unlikely circumstance that the provider
   // renders before the offlineInterface has received a value for
   // lastIsConnected. Normally, the ServerVersionProvider in the app
   // adapter delays rendering the App Runtime provider (including the
   // OfflineProvider) until the offline interface is ready, which should
   // avoid this case.
-
   test('when latestIsConnected is null', () => {
-    const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    const customMockOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       latestIsConnected: null
     };
-
-    const customWrapper = (_ref3) => {
+    const customWrapper = _ref3 => {
       let {
         children
       } = _ref3;
-      return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+      return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
         offlineInterface: customMockOfflineInterface
       }, children);
     };
-
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: customWrapper
     });
     expect(result.current.isConnected).toBe(true);
@@ -172,111 +160,124 @@ describe('interval behavior', () => {
     const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
     });
     expect(result.current.isConnected).toBe(true);
     expect(mockPing).not.toHaveBeenCalled();
-    assertLastDelay(setTimeoutSpy, FIRST_INTERVAL_MS); // 500ms before first interval
+    assertLastDelay(setTimeoutSpy, FIRST_INTERVAL_MS);
 
+    // 500ms before first interval
     jest.advanceTimersByTime(FIRST_INTERVAL_MS - 500);
-    expect(mockPing).not.toHaveBeenCalled(); // 500ms after first interval
-
+    expect(mockPing).not.toHaveBeenCalled();
+    // 500ms after first interval
     jest.advanceTimersByTime(1000);
     expect(mockPing).toHaveBeenCalledTimes(1);
-    assertLastDelay(setTimeoutSpy, SECOND_INTERVAL_MS); // 500ms before second interval
+    assertLastDelay(setTimeoutSpy, SECOND_INTERVAL_MS);
 
+    // 500ms before second interval
     jest.advanceTimersByTime(SECOND_INTERVAL_MS - 1000);
-    expect(mockPing).toHaveBeenCalledTimes(1); // 500ms after second interval
-
+    expect(mockPing).toHaveBeenCalledTimes(1);
+    // 500ms after second interval
     jest.advanceTimersByTime(1000);
     expect(mockPing).toHaveBeenCalledTimes(2);
-    assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // 500ms before third interval
+    assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
+    // 500ms before third interval
     jest.advanceTimersByTime(THIRD_INTERVAL_MS - 1000);
-    expect(mockPing).toHaveBeenCalledTimes(2); // 500ms after third interval
-
+    expect(mockPing).toHaveBeenCalledTimes(2);
+    // 500ms after third interval
     jest.advanceTimersByTime(1000);
     expect(mockPing).toHaveBeenCalledTimes(3);
-    assertLastDelay(setTimeoutSpy, FOURTH_INTERVAL_MS); // Run a number of intervals to reach the max delay -
+    assertLastDelay(setTimeoutSpy, FOURTH_INTERVAL_MS);
+
+    // Run a number of intervals to reach the max delay -
     // this number is calculated above to work for any default values.
     // Since three have already elapsed, there will be some extra too
-
     for (let i = 0; i < INTERVALS_TO_REACH_MAX_DELAY; i++) {
       // Wrap in act to await async side effects of interval execution
       // and pings
-      await (0, _reactHooks.act)(async () => {
+      await (0, _react.act)(async () => {
         jest.runOnlyPendingTimers();
       });
-    } // Timeout should no longer be incrementing; max has been reached
-
+    }
 
+    // Timeout should no longer be incrementing; max has been reached
     expect(mockPing).toHaveBeenCalledTimes(3 + INTERVALS_TO_REACH_MAX_DELAY);
-    assertLastDelay(setTimeoutSpy, _smartInterval.DEFAULT_MAX_DELAY_MS); // Run a few more intervals to make sure it stays at max
+    assertLastDelay(setTimeoutSpy, _smartInterval.DEFAULT_MAX_DELAY_MS);
 
+    // Run a few more intervals to make sure it stays at max
     for (let i = 0; i < 3; i++) {
-      await (0, _reactHooks.act)(async () => {
+      await (0, _react.act)(async () => {
         jest.runOnlyPendingTimers();
       });
-    } // Expect continued use of the max delay
-
+    }
 
+    // Expect continued use of the max delay
     expect(mockPing).toHaveBeenCalledTimes(6 + INTERVALS_TO_REACH_MAX_DELAY);
     assertLastDelay(setTimeoutSpy, _smartInterval.DEFAULT_MAX_DELAY_MS);
   });
   describe('pings are delayed when offlineInterface sends status updates', () => {
     test('updates postpone pings', () => {
-      (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
+      });
 
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
-      } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0]; // invoke it at a few intervals, before pings are scheduled
+      } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
 
+      // invoke it at a few intervals, before pings are scheduled
       for (let i = 0; i < 3; i++) {
         jest.advanceTimersByTime(_smartInterval.DEFAULT_INITIAL_DELAY_MS - 2000);
         onUpdate({
           isConnected: true
         });
-      } // expect ping mock not to have been called
-
+      }
 
+      // expect ping mock not to have been called
       expect(mockPing).not.toHaveBeenCalled;
     });
     test('if the status is the same, the ping delay is reset to the current', () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
-      (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
+      });
 
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
-      } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0]; // let two intervals pass to allow delay to increase
+      } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
 
+      // let two intervals pass to allow delay to increase
       jest.advanceTimersByTime(FIRST_INTERVAL_MS + 50);
-      jest.advanceTimersByTime(SECOND_INTERVAL_MS); // ...delay should now be 'THIRD_INTERVAL_MS'
+      jest.advanceTimersByTime(SECOND_INTERVAL_MS);
 
+      // ...delay should now be 'THIRD_INTERVAL_MS'
       assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
-      expect(mockPing).toHaveBeenCalledTimes(2); // simulate updates from the SW/offline interface several times
-      // invoke it at a few intervals, before pings are scheduled
+      expect(mockPing).toHaveBeenCalledTimes(2);
 
+      // simulate updates from the SW/offline interface several times
+      // invoke it at a few intervals, before pings are scheduled
       for (let i = 0; i < 3; i++) {
         jest.advanceTimersByTime(THIRD_INTERVAL_MS - 2000);
         onUpdate({
           isConnected: true
         });
-      } // ping mock should STILL only have been called twice
+      }
 
+      // ping mock should STILL only have been called twice
+      expect(mockPing).toHaveBeenCalledTimes(2);
 
-      expect(mockPing).toHaveBeenCalledTimes(2); // the delay should still be THIRD_INTERVAL_MS
+      // the delay should still be THIRD_INTERVAL_MS
+      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
-      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // The timer works as normal for the next tick --
+      // The timer works as normal for the next tick --
       // 500ms before the fourth interval:
-
       jest.advanceTimersByTime(THIRD_INTERVAL_MS - 500);
-      expect(mockPing).toHaveBeenCalledTimes(2); // 500ms after the fourth interval
-
+      expect(mockPing).toHaveBeenCalledTimes(2);
+      // 500ms after the fourth interval
       jest.advanceTimersByTime(1000);
       expect(mockPing).toHaveBeenCalledTimes(3);
     });
@@ -286,42 +287,47 @@ describe('interval behavior', () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
       const {
         result
-      } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
-
+      });
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
       } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
-      expect(result.current.isConnected).toBe(true); // Get to third interval
-      // (Wrap in `act` to await async side effects of the executions)
+      expect(result.current.isConnected).toBe(true);
 
-      await (0, _reactHooks.act)(async () => {
+      // Get to third interval
+      // (Wrap in `act` to await async side effects of the executions)
+      await (0, _react.act)(async () => {
         jest.runOnlyPendingTimers();
         jest.runOnlyPendingTimers();
       });
       expect(mockPing).toHaveBeenCalledTimes(2);
-      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // Trigger connection status change from offline interface
+      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
-      await (0, _reactHooks.act)(async () => {
+      // Trigger connection status change from offline interface
+      await (0, _react.act)(async () => {
         onUpdate({
           isConnected: false
         });
-      }); // Expect "first interval delay" to be set up
+      });
 
+      // Expect "first interval delay" to be set up
       assertLastDelay(setTimeoutSpy, FIRST_INTERVAL_MS);
-      expect(result.current.isConnected).toBe(false); // Mock an error for the next ping to maintain `isConnected: false`
+      expect(result.current.isConnected).toBe(false);
 
+      // Mock an error for the next ping to maintain `isConnected: false`
       mockPing.mockImplementationOnce(() => Promise.reject({
         message: 'this is a network error',
         type: 'network'
-      })); // Advance past "first interval" -- make sure incrementing resumes
+      }));
+      // Advance past "first interval" -- make sure incrementing resumes
       // while still 'isConnected: false'
-
-      await (0, _reactHooks.act)(async () => {
+      await (0, _react.act)(async () => {
         jest.advanceTimersByTime(FIRST_INTERVAL_MS + 50);
-      }); // Expect another execution with the incremented interval
+      });
 
+      // Expect another execution with the incremented interval
       expect(mockPing).toHaveBeenCalledTimes(3);
       assertLastDelay(setTimeoutSpy, SECOND_INTERVAL_MS);
     });
@@ -329,21 +335,23 @@ describe('interval behavior', () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
       const {
         result
-      } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: wrapper
       });
-      expect(result.current.isConnected).toBe(true); // Get to third interval
+      expect(result.current.isConnected).toBe(true);
 
+      // Get to third interval
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
       expect(mockPing).toHaveBeenCalledTimes(2);
-      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // Mock a network error
+      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
+      // Mock a network error
       mockPing.mockImplementationOnce(() => Promise.reject({
         message: 'this is a network error',
         type: 'network'
       }));
-      await (0, _reactHooks.act)(async () => {
+      await (0, _react.act)(async () => {
         jest.advanceTimersByTime(THIRD_INTERVAL_MS + 50);
       });
       expect(result.current.isConnected).toBe(false);
@@ -354,111 +362,126 @@ describe('interval behavior', () => {
 });
 describe('pings aren\'t sent when the app is not focused; "standby behavior"', () => {
   test("it doesn't ping when the app loses focus and is never refocused", () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
-    window.dispatchEvent(new Event('blur')); // This recursively executes all timers -- if it's not in standby,
-    // it will enter a loop
+    window.dispatchEvent(new Event('blur'));
 
+    // This recursively executes all timers -- if it's not in standby,
+    // it will enter a loop
     jest.runAllTimers();
     expect(mockPing).not.toHaveBeenCalled();
   });
   test("it doesn't ping if the app is never focused (even upon startup)", () => {
     jest.spyOn(document, 'hasFocus').mockReturnValue(false);
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
-    }); // This recursively executes all timers
+    });
 
+    // This recursively executes all timers
     jest.runAllTimers();
     expect(mockPing).not.toHaveBeenCalled();
   });
   test('if the app is defocused and refocused between two pings, pings happen normally', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
-    window.dispatchEvent(new Event('blur')); // wait half of the first interval
-
+    window.dispatchEvent(new Event('blur'));
+    // wait half of the first interval
     jest.advanceTimersByTime(FIRST_INTERVAL_MS / 2);
-    window.dispatchEvent(new Event('focus')); // wait for just over the second half of the first interval
+    window.dispatchEvent(new Event('focus'));
 
-    jest.advanceTimersByTime(FIRST_INTERVAL_MS / 2 + 50); // ping should execute normally
+    // wait for just over the second half of the first interval
+    jest.advanceTimersByTime(FIRST_INTERVAL_MS / 2 + 50);
 
+    // ping should execute normally
     expect(mockPing).toHaveBeenCalledTimes(1);
   });
   test('if the app is defocused until after a scheduled ping, that ping is not sent until the app is refocused', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
-    window.dispatchEvent(new Event('blur')); // wait for twice the first interval
+    window.dispatchEvent(new Event('blur'));
 
-    jest.advanceTimersByTime(FIRST_INTERVAL_MS * 2); // no pings should be sent since it's in standby
+    // wait for twice the first interval
+    jest.advanceTimersByTime(FIRST_INTERVAL_MS * 2);
 
-    expect(mockPing).not.toHaveBeenCalled(); // refocus the page
+    // no pings should be sent since it's in standby
+    expect(mockPing).not.toHaveBeenCalled();
 
-    window.dispatchEvent(new Event('focus')); // ping should execute immediately
+    // refocus the page
+    window.dispatchEvent(new Event('focus'));
 
+    // ping should execute immediately
     expect(mockPing).toHaveBeenCalledTimes(1);
   });
 });
 describe('it pings when an offline event is detected', () => {
   test('if the app is focused, it pings immediately', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
-    window.dispatchEvent(new Event('offline')); // ping should execute immediately
+    window.dispatchEvent(new Event('offline'));
 
+    // ping should execute immediately
     expect(mockPing).toHaveBeenCalledTimes(1);
   });
   test('if the app is not focused, it does not ping immediately, but pings immediately when refocused', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
     window.dispatchEvent(new Event('blur'));
-    window.dispatchEvent(new Event('offline')); // ping should not execute, but should be queued for refocus
+    window.dispatchEvent(new Event('offline'));
 
-    expect(mockPing).toHaveBeenCalledTimes(0); // upon refocus, the ping should execute immediately
-    // despite a full interval not elapsing
+    // ping should not execute, but should be queued for refocus
+    expect(mockPing).toHaveBeenCalledTimes(0);
 
+    // upon refocus, the ping should execute immediately
+    // despite a full interval not elapsing
     window.dispatchEvent(new Event('focus'));
     expect(mockPing).toHaveBeenCalledTimes(1);
   });
   describe('interval handling when pinging upon refocusing after offline event is detected while not focused', () => {
     test('if the app is refocused before the next "scheduled" ping, the timeout to the next ping is not increased', () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
-      (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper
       });
       window.dispatchEvent(new Event('blur'));
       window.dispatchEvent(new Event('offline'));
-      window.dispatchEvent(new Event('focus')); // upon refocus, the ping should execute immediately
+      window.dispatchEvent(new Event('focus'));
+      // upon refocus, the ping should execute immediately
       // despite a full interval not elapsing
+      expect(mockPing).toHaveBeenCalledTimes(1);
 
-      expect(mockPing).toHaveBeenCalledTimes(1); // The delay should be the initial again -- it shouldn't increment
-
+      // The delay should be the initial again -- it shouldn't increment
       assertLastDelay(setTimeoutSpy, FIRST_INTERVAL_MS);
     });
     test('same as previous, but interval is reset if status changes', async () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
       const {
         result
-      } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: wrapper
       });
-      expect(result.current.isConnected).toBe(true); // Get to third interval
+      expect(result.current.isConnected).toBe(true);
 
+      // Get to third interval
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
       expect(mockPing).toHaveBeenCalledTimes(2);
-      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // Mock a network error
+      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
+      // Mock a network error
       mockPing.mockImplementationOnce(() => Promise.reject({
         message: 'this is a network error',
         type: 'network'
-      })); // Blur, trigger 'offline' event, and refocus to trigger a ping
+      }));
 
+      // Blur, trigger 'offline' event, and refocus to trigger a ping
       window.dispatchEvent(new Event('blur'));
       window.dispatchEvent(new Event('offline'));
-      await (0, _reactHooks.act)(async () => {
+      await (0, _react.act)(async () => {
         window.dispatchEvent(new Event('focus'));
       });
       expect(result.current.isConnected).toBe(false);
@@ -467,46 +490,53 @@ describe('it pings when an offline event is detected', () => {
     });
     test('if the app is refocused after the next "scheduled" ping, increase the interval to the next ping if the status hasn\'t changed', () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
-      (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper
       });
       window.dispatchEvent(new Event('blur'));
-      window.dispatchEvent(new Event('offline')); // Elapse twice one interval - it should enter full standby
+      window.dispatchEvent(new Event('offline'));
 
+      // Elapse twice one interval - it should enter full standby
       jest.advanceTimersByTime(FIRST_INTERVAL_MS * 2);
-      expect(mockPing).toHaveBeenCalledTimes(0); // Refocusing should trigger a ping from the full standby,
-      // not just the offline event
+      expect(mockPing).toHaveBeenCalledTimes(0);
 
+      // Refocusing should trigger a ping from the full standby,
+      // not just the offline event
       window.dispatchEvent(new Event('focus'));
-      expect(mockPing).toHaveBeenCalledTimes(1); // The delay should increment this time, as it would from normal standby
+      expect(mockPing).toHaveBeenCalledTimes(1);
 
+      // The delay should increment this time, as it would from normal standby
       assertLastDelay(setTimeoutSpy, SECOND_INTERVAL_MS);
     });
     test('the same as previous, but the interval is reset if status has changed', async () => {
       const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
       const {
         result
-      } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: wrapper
       });
-      expect(result.current.isConnected).toBe(true); // Get to third interval
+      expect(result.current.isConnected).toBe(true);
 
+      // Get to third interval
       jest.runOnlyPendingTimers();
       jest.runOnlyPendingTimers();
       expect(mockPing).toHaveBeenCalledTimes(2);
-      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS); // Blur and elapse twice the third interval --
-      // it should enter full standby
+      assertLastDelay(setTimeoutSpy, THIRD_INTERVAL_MS);
 
+      // Blur and elapse twice the third interval --
+      // it should enter full standby
       window.dispatchEvent(new Event('blur'));
       window.dispatchEvent(new Event('offline'));
-      jest.advanceTimersByTime(THIRD_INTERVAL_MS * 2); // Mock a network error for the next ping
+      jest.advanceTimersByTime(THIRD_INTERVAL_MS * 2);
 
+      // Mock a network error for the next ping
       mockPing.mockImplementationOnce(() => Promise.reject({
         message: 'this is a network error',
         type: 'network'
-      })); // Trigger a ping by refocusing
+      }));
 
-      await (0, _reactHooks.act)(async () => {
+      // Trigger a ping by refocusing
+      await (0, _react.act)(async () => {
         window.dispatchEvent(new Event('focus'));
       });
       expect(result.current.isConnected).toBe(false);
@@ -517,7 +547,7 @@ describe('it pings when an offline event is detected', () => {
 });
 describe('it pings when an online event is detected', () => {
   test('if the app is focused, it pings immediately', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
     window.dispatchEvent(new Event('offline'));
@@ -526,63 +556,73 @@ describe('it pings when an online event is detected', () => {
     expect(mockPing).toHaveBeenCalledTimes(2);
   });
   test('pings are throttled', () => {
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
     window.dispatchEvent(new Event('offline'));
     window.dispatchEvent(new Event('online'));
     window.dispatchEvent(new Event('offline'));
     expect(mockPing).toHaveBeenCalledTimes(3);
-    window.dispatchEvent(new Event('online')); // Another ping should NOT be sent immediately after this latest
+    window.dispatchEvent(new Event('online'));
+    // Another ping should NOT be sent immediately after this latest
     // online event
-
-    expect(mockPing).toHaveBeenCalledTimes(3); // (Not testing throttle time here because further pings may interfere)
+    expect(mockPing).toHaveBeenCalledTimes(3);
+    // (Not testing throttle time here because further pings may interfere)
   });
 });
 describe('lastConnected status', () => {
   test('it sets lastConnected in localStorage when it becomes disconnected', async () => {
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
     });
-    expect(result.current.isConnected).toBe(true); // Mock a network error for the next ping
+    expect(result.current.isConnected).toBe(true);
 
-    mockPing.mockImplementationOnce(failedPing); // Trigger a ping (to fail and switch to disconnected)
+    // Mock a network error for the next ping
+    mockPing.mockImplementationOnce(failedPing);
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger a ping (to fail and switch to disconnected)
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(mockPing).toHaveBeenCalledTimes(1); // Expect 'disconnected' status now
+    expect(mockPing).toHaveBeenCalledTimes(1);
 
+    // Expect 'disconnected' status now
     expect(result.current.isConnected).toBe(false);
-    expect(result.current.isDisconnected).toBe(true); // Check localStorage for the dummy date
+    expect(result.current.isDisconnected).toBe(true);
 
+    // Check localStorage for the dummy date
     const localStorageDate = localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)());
-    expect(localStorageDate).toBe(testCurrentDate.toUTCString()); // Check hook return value
+    expect(localStorageDate).toBe(testCurrentDate.toUTCString());
 
+    // Check hook return value
     expect(result.current.lastConnected).toBeInstanceOf(Date);
     expect(result.current.lastConnected).toEqual(testCurrentDate);
   });
   test('lastConnected becomes null when it becomes connected again', async () => {
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
     });
-    expect(result.current.isConnected).toBe(true); // Mock a network error for the next ping
+    expect(result.current.isConnected).toBe(true);
 
-    mockPing.mockImplementationOnce(failedPing); // Trigger an immediate ping (to fail and switch to disconnected)
+    // Mock a network error for the next ping
+    mockPing.mockImplementationOnce(failedPing);
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger an immediate ping (to fail and switch to disconnected)
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(mockPing).toHaveBeenCalledTimes(1); // Verify hook return value
+    expect(mockPing).toHaveBeenCalledTimes(1);
 
+    // Verify hook return value
     expect(result.current.isConnected).toBe(false);
-    expect(result.current.lastConnected).toEqual(testCurrentDate); // Trigger a successful ping to go back online
+    expect(result.current.lastConnected).toEqual(testCurrentDate);
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger a successful ping to go back online
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
     expect(mockPing).toHaveBeenCalledTimes(2);
@@ -593,18 +633,21 @@ describe('lastConnected status', () => {
     const {
       result,
       unmount
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
-    }); // Mock a network error for the next ping to trigger 'disconnected'
+    });
 
+    // Mock a network error for the next ping to trigger 'disconnected'
     mockPing.mockImplementationOnce(failedPing);
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(result.current.isConnected).toBe(false); // Unmount
+    expect(result.current.isConnected).toBe(false);
 
-    unmount(); // Expect value to persist in localStorage
+    // Unmount
+    unmount();
 
+    // Expect value to persist in localStorage
     const localStorageDate = localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)());
     expect(localStorageDate).toBe(testCurrentDate.toUTCString());
   });
@@ -612,25 +655,29 @@ describe('lastConnected status', () => {
     const {
       result,
       unmount
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper
     });
-    expect(result.current.isConnected).toBe(true); // Mock a network error for the next ping to trigger disconnected
+    expect(result.current.isConnected).toBe(true);
 
+    // Mock a network error for the next ping to trigger disconnected
     mockPing.mockImplementationOnce(failedPing);
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(result.current.isConnected).toBe(false); // Check localStorage for the dummy date
+    expect(result.current.isConnected).toBe(false);
 
+    // Check localStorage for the dummy date
     const localStorageDate = localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)());
-    expect(localStorageDate).toBe(testCurrentDate.toUTCString()); // Trigger another ping to go back to connected
+    expect(localStorageDate).toBe(testCurrentDate.toUTCString());
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger another ping to go back to connected
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(result.current.isConnected).toBe(true); // Unmount and expect localStorage to be clear for next session
+    expect(result.current.isConnected).toBe(true);
 
+    // Unmount and expect localStorage to be clear for next session
     unmount();
     expect(localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)())).toBe(null);
   });
@@ -638,70 +685,73 @@ describe('lastConnected status', () => {
     test('it sets lastConnected to `now` if nothing is found in localStorage', async () => {
       // use a custom offlineInterface with `latestIsConnected: false`
       // to initialize the `isConnected` state to false
-      const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+      const customMockOfflineInterface = {
+        ..._testMocks.mockOfflineInterface,
         latestIsConnected: false
       };
-
-      const customWrapper = (_ref4) => {
+      const customWrapper = _ref4 => {
         let {
           children
         } = _ref4;
-        return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+        return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
           offlineInterface: customMockOfflineInterface
         }, children);
-      }; // render hook with custom wrapper
-
+      };
 
-      (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      // render hook with custom wrapper
+      (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: customWrapper
-      }); // expect correct lastConnected time (mocked Date.now())
+      });
 
+      // expect correct lastConnected time (mocked Date.now())
       expect(localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)())).toBe(testCurrentDate.toUTCString());
     });
     test('if a value is already in localStorage, it uses that without overwriting', async () => {
       // seed localStorage with an imaginary 'lastConnected' value from last session
       const testPreviousDate = new Date('2023-01-01');
-      localStorage.setItem((0, _dhis2ConnectionStatus.getLastConnectedKey)(), testPreviousDate.toUTCString()); // render hook with custom wrapper
+      localStorage.setItem((0, _dhis2ConnectionStatus.getLastConnectedKey)(), testPreviousDate.toUTCString());
 
-      const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+      // render hook with custom wrapper
+      const customMockOfflineInterface = {
+        ..._testMocks.mockOfflineInterface,
         latestIsConnected: false
       };
-
-      const customWrapper = (_ref5) => {
+      const customWrapper = _ref5 => {
         let {
           children
         } = _ref5;
-        return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+        return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
           offlineInterface: customMockOfflineInterface
         }, children);
       };
-
       const {
         result
-      } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+      } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
         wrapper: customWrapper
-      }); // On render, the hook should retain last connected
+      });
 
+      // On render, the hook should retain last connected
       expect(result.current.lastConnected).not.toBe(null);
-      expect(result.current.lastConnected).toEqual(testPreviousDate); // should be the same in localStorage too
-
+      expect(result.current.lastConnected).toEqual(testPreviousDate);
+      // should be the same in localStorage too
       expect(localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)())).toBe(testPreviousDate.toUTCString());
     });
   });
   test("it doesn't change lastConnected if already disconnected", async () => {
     // seed localStorage with an imaginary 'lastConnected' value from last session
     const testPreviousDate = new Date('2023-01-01');
-    localStorage.setItem((0, _dhis2ConnectionStatus.getLastConnectedKey)(), testPreviousDate.toUTCString()); // render hook with custom wrapper
+    localStorage.setItem((0, _dhis2ConnectionStatus.getLastConnectedKey)(), testPreviousDate.toUTCString());
 
-    const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    // render hook with custom wrapper
+    const customMockOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref6) => {
+    const customWrapper = _ref6 => {
       let {
         children
       } = _ref6;
-      return /*#__PURE__*/_react.default.createElement(_appServiceConfig.ConfigProvider, {
+      return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
         config: {
           baseUrl: '..',
           apiVersion: 42,
@@ -712,39 +762,43 @@ describe('lastConnected status', () => {
             full: 'n/a'
           }
         }
-      }, /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+      }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
         offlineInterface: customMockOfflineInterface
       }, children));
     };
-
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: customWrapper
-    }); // As in previous test, the hook should retain last connected
+    });
 
-    expect(result.current.lastConnected).toEqual(testPreviousDate); // Mock a network error for the next ping and trigger
+    // As in previous test, the hook should retain last connected
+    expect(result.current.lastConnected).toEqual(testPreviousDate);
 
+    // Mock a network error for the next ping and trigger
     mockPing.mockImplementationOnce(failedPing);
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(mockPing).toHaveBeenCalledTimes(1); // Expect the same lastConnected as before
+    expect(mockPing).toHaveBeenCalledTimes(1);
 
-    expect(result.current.lastConnected).toEqual(testPreviousDate); // should be the same in localStorage too
+    // Expect the same lastConnected as before
+    expect(result.current.lastConnected).toEqual(testPreviousDate);
+    // should be the same in localStorage too
+    expect(localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)())).toBe(testPreviousDate.toUTCString());
 
-    expect(localStorage.getItem((0, _dhis2ConnectionStatus.getLastConnectedKey)())).toBe(testPreviousDate.toUTCString()); // Verify the same with a signal from the service worker
+    // Verify the same with a signal from the service worker
     // get onUpdate function passed to mockOfflineInterface
-
     const {
       onUpdate
     } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       onUpdate({
         isConnected: false
       });
-    }); // Expect the same lastConnected as before
+    });
 
+    // Expect the same lastConnected as before
     expect(result.current.lastConnected).toEqual(testPreviousDate);
   });
   test('lastConnected is saved specifically to an app if a name is provided', async () => {
@@ -752,17 +806,18 @@ describe('lastConnected status', () => {
     const testAppName = 'test-app-name';
     const lastConnectedKey = (0, _dhis2ConnectionStatus.getLastConnectedKey)(testAppName);
     const testPreviousDate = new Date('2023-01-01');
-    localStorage.setItem(lastConnectedKey, testPreviousDate.toUTCString()); // render hook with custom wrapper to start disconnected with app name
+    localStorage.setItem(lastConnectedKey, testPreviousDate.toUTCString());
 
-    const customMockOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    // render hook with custom wrapper to start disconnected with app name
+    const customMockOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref7) => {
+    const customWrapper = _ref7 => {
       let {
         children
       } = _ref7;
-      return /*#__PURE__*/_react.default.createElement(_appServiceConfig.ConfigProvider, {
+      return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
         config: {
           baseUrl: '..',
           apiVersion: 42,
@@ -774,42 +829,44 @@ describe('lastConnected status', () => {
             full: 'n/a'
           }
         }
-      }, /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+      }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
         offlineInterface: customMockOfflineInterface
       }, children));
     };
-
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: customWrapper
-    }); // Expect previous value to be read correctly
+    });
 
-    expect(result.current.lastConnected).toEqual(testPreviousDate); // Go to connected then disconnected again to generate a new date
+    // Expect previous value to be read correctly
+    expect(result.current.lastConnected).toEqual(testPreviousDate);
 
-    await (0, _reactHooks.act)(async () => {
+    // Go to connected then disconnected again to generate a new date
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
     expect(result.current.isConnected).toBe(true);
     expect(result.current.lastConnected).toBe(null);
     expect(localStorage.getItem(lastConnectedKey)).toBe(null);
     mockPing.mockImplementationOnce(failedPing);
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       jest.runOnlyPendingTimers();
     });
-    expect(result.current.isConnected).toBe(false); // Note the new date:
-
-    expect(result.current.lastConnected).toEqual(testCurrentDate); // Verify localStorage
+    expect(result.current.isConnected).toBe(false);
+    // Note the new date:
+    expect(result.current.lastConnected).toEqual(testCurrentDate);
 
+    // Verify localStorage
     expect(localStorage.getItem(lastConnectedKey)).toBe(testCurrentDate.toUTCString());
   });
 });
 describe("when the /api/ping endpoint isn't supported", () => {
-  const customWrapper = (_ref8) => {
+  const customWrapper = _ref8 => {
     let {
       children
     } = _ref8;
-    return /*#__PURE__*/_react.default.createElement(_appServiceConfig.ConfigProvider, {
+    return /*#__PURE__*/_react2.default.createElement(_appServiceConfig.ConfigProvider, {
       config: {
         baseUrl: '..',
         apiVersion: 42,
@@ -821,17 +878,16 @@ describe("when the /api/ping endpoint isn't supported", () => {
           full: 'n/a'
         }
       }
-    }, /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+    }, /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: _testMocks.mockOfflineInterface
     }, children));
   };
-
   test("pings aren't sent", async () => {
     const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
-    (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: customWrapper
     });
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       jest.runAllTimers();
     });
     expect(mockPing).not.toHaveBeenCalled();
@@ -840,22 +896,23 @@ describe("when the /api/ping endpoint isn't supported", () => {
   test('service worker updates still work', async () => {
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
+    } = (0, _react.renderHook)(() => (0, _dhis2ConnectionStatus.useDhis2ConnectionStatus)(), {
       wrapper: wrapper
-    }); // get onUpdate function passed to mockOfflineInterface
-
+    });
+    // get onUpdate function passed to mockOfflineInterface
     const {
       onUpdate
     } = _testMocks.mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
-    expect(result.current.isConnected).toBe(true); // Trigger connection status change from offline interface
+    expect(result.current.isConnected).toBe(true);
 
-    await (0, _reactHooks.act)(async () => {
+    // Trigger connection status change from offline interface
+    await (0, _react.act)(async () => {
       onUpdate({
         isConnected: false
       });
     });
     expect(result.current.isConnected).toBe(false);
-    await (0, _reactHooks.act)(async () => {
+    await (0, _react.act)(async () => {
       onUpdate({
         isConnected: true
       });