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

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

@@ -1,35 +1,34 @@
 import { ConfigProvider } from '@dhis2/app-service-config';
-import { renderHook, act } from '@testing-library/react-hooks';
+import { renderHook, act } from '@testing-library/react';
 import React from 'react';
 import { mockOfflineInterface } from '../../utils/test-mocks';
 import { OfflineProvider } from '../offline-provider';
 import { getLastConnectedKey, useDhis2ConnectionStatus } from './dhis2-connection-status';
-import { DEFAULT_INCREMENT_FACTOR, DEFAULT_MAX_DELAY_MS, DEFAULT_INITIAL_DELAY_MS } from './smart-interval'; // eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { DEFAULT_INCREMENT_FACTOR, DEFAULT_MAX_DELAY_MS, DEFAULT_INITIAL_DELAY_MS } from './smart-interval';
+// 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 = DEFAULT_INITIAL_DELAY_MS;
 const SECOND_INTERVAL_MS = FIRST_INTERVAL_MS * DEFAULT_INCREMENT_FACTOR;
 const THIRD_INTERVAL_MS = SECOND_INTERVAL_MS * DEFAULT_INCREMENT_FACTOR;
-const FOURTH_INTERVAL_MS = THIRD_INTERVAL_MS * DEFAULT_INCREMENT_FACTOR; // Explanation: The length of the Nth interval is:
+const FOURTH_INTERVAL_MS = THIRD_INTERVAL_MS * 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(DEFAULT_MAX_DELAY_MS / DEFAULT_INITIAL_DELAY_MS) / Math.log(DEFAULT_INCREMENT_FACTOR) + 1);
-
-const wrapper = (_ref) => {
+const wrapper = _ref => {
   let {
     children
   } = _ref;
@@ -49,6 +48,7 @@ const wrapper = (_ref) => {
     offlineInterface: mockOfflineInterface
   }, children));
 };
+
 /**
  * Assert on the delay of the last time setTimeoutSpy was called with
  * the `callbackAndRestart()` function in smartInterval.
@@ -58,11 +58,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);
@@ -70,7 +67,6 @@ const assertLastDelay = (setTimeoutSpy, expectedDelay) => {
     }
   }
 };
-
 const testCurrentDate = new Date('Fri, 03 Feb 2023 13:52:31 GMT');
 beforeAll(() => {
   jest.useFakeTimers();
@@ -82,8 +78,8 @@ beforeEach(() => {
   jest.spyOn(document, 'hasFocus').mockReturnValue(true);
 });
 afterEach(() => {
-  jest.clearAllMocks(); // for lastConnected:
-
+  jest.clearAllMocks();
+  // for lastConnected:
   localStorage.clear();
 });
 afterAll(() => {
@@ -102,11 +98,11 @@ describe('initialization to the right values based on offline interface', () =>
     expect(result.current.lastConnected).toBe(null);
   });
   test('when latestIsConnected is false', () => {
-    const customMockOfflineInterface = { ...mockOfflineInterface,
+    const customMockOfflineInterface = {
+      ...mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref2) => {
+    const customWrapper = _ref2 => {
       let {
         children
       } = _ref2;
@@ -114,31 +110,31 @@ describe('initialization to the right values based on offline interface', () =>
         offlineInterface: customMockOfflineInterface
       }, children);
     };
-
     const {
       result
     } = renderHook(() => 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 = { ...mockOfflineInterface,
+    const customMockOfflineInterface = {
+      ...mockOfflineInterface,
       latestIsConnected: null
     };
-
-    const customWrapper = (_ref3) => {
+    const customWrapper = _ref3 => {
       let {
         children
       } = _ref3;
@@ -146,7 +142,6 @@ describe('initialization to the right values based on offline interface', () =>
         offlineInterface: customMockOfflineInterface
       }, children);
     };
-
     const {
       result
     } = renderHook(() => useDhis2ConnectionStatus(), {
@@ -167,50 +162,55 @@ describe('interval behavior', () => {
     });
     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 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, DEFAULT_MAX_DELAY_MS); // Run a few more intervals to make sure it stays at max
+    assertLastDelay(setTimeoutSpy, DEFAULT_MAX_DELAY_MS);
 
+    // Run a few more intervals to make sure it stays at max
     for (let i = 0; i < 3; i++) {
       await 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, DEFAULT_MAX_DELAY_MS);
   });
@@ -218,55 +218,63 @@ describe('interval behavior', () => {
     test('updates postpone pings', () => {
       renderHook(() => useDhis2ConnectionStatus(), {
         wrapper: wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
+      });
 
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
-      } = mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0]; // invoke it at a few intervals, before pings are scheduled
+      } = 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(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');
       renderHook(() => useDhis2ConnectionStatus(), {
         wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
+      });
 
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
-      } = mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0]; // let two intervals pass to allow delay to increase
+      } = 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);
     });
@@ -278,40 +286,45 @@ describe('interval behavior', () => {
         result
       } = renderHook(() => useDhis2ConnectionStatus(), {
         wrapper: wrapper
-      }); // get onUpdate function passed to mockOfflineInterface
-
+      });
+      // get onUpdate function passed to mockOfflineInterface
       const {
         onUpdate
       } = 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);
 
+      // Get to third interval
+      // (Wrap in `act` to await async side effects of the executions)
       await 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);
 
+      // Trigger connection status change from offline interface
       await 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 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);
     });
@@ -322,13 +335,15 @@ describe('interval behavior', () => {
       } = renderHook(() => 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'
@@ -347,9 +362,10 @@ describe('pings aren\'t sent when the app is not focused; "standby behavior"', (
     renderHook(() => 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();
   });
@@ -357,8 +373,9 @@ describe('pings aren\'t sent when the app is not focused; "standby behavior"', (
     jest.spyOn(document, 'hasFocus').mockReturnValue(false);
     renderHook(() => useDhis2ConnectionStatus(), {
       wrapper
-    }); // This recursively executes all timers
+    });
 
+    // This recursively executes all timers
     jest.runAllTimers();
     expect(mockPing).not.toHaveBeenCalled();
   });
@@ -366,27 +383,33 @@ describe('pings aren\'t sent when the app is not focused; "standby behavior"', (
     renderHook(() => 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', () => {
     renderHook(() => 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);
   });
 });
@@ -395,8 +418,9 @@ describe('it pings when an offline event is detected', () => {
     renderHook(() => 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', () => {
@@ -404,11 +428,13 @@ describe('it pings when an offline event is detected', () => {
       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);
   });
@@ -420,11 +446,12 @@ describe('it pings when an offline event is detected', () => {
       });
       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 () => {
@@ -434,18 +461,21 @@ describe('it pings when an offline event is detected', () => {
       } = renderHook(() => 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 act(async () => {
@@ -461,15 +491,18 @@ describe('it pings when an offline event is detected', () => {
         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 () => {
@@ -479,23 +512,27 @@ describe('it pings when an offline event is detected', () => {
       } = renderHook(() => 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
+      }));
 
+      // Trigger a ping by refocusing
       await act(async () => {
         window.dispatchEvent(new Event('focus'));
       });
@@ -523,10 +560,11 @@ describe('it pings when an online event is detected', () => {
     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', () => {
@@ -536,21 +574,26 @@ describe('lastConnected status', () => {
     } = renderHook(() => 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);
 
+    // Trigger a ping (to fail and switch to disconnected)
     await 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(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);
   });
@@ -560,18 +603,22 @@ describe('lastConnected status', () => {
     } = renderHook(() => 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);
 
+    // Trigger an immediate ping (to fail and switch to disconnected)
     await 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);
 
+    // Trigger a successful ping to go back online
     await act(async () => {
       jest.runOnlyPendingTimers();
     });
@@ -585,16 +632,19 @@ describe('lastConnected status', () => {
       unmount
     } = renderHook(() => 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 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(getLastConnectedKey());
     expect(localStorageDate).toBe(testCurrentDate.toUTCString());
   });
@@ -605,22 +655,26 @@ describe('lastConnected status', () => {
     } = renderHook(() => 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 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(getLastConnectedKey());
-    expect(localStorageDate).toBe(testCurrentDate.toUTCString()); // Trigger another ping to go back to connected
+    expect(localStorageDate).toBe(testCurrentDate.toUTCString());
 
+    // Trigger another ping to go back to connected
     await 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(getLastConnectedKey())).toBe(null);
   });
@@ -628,36 +682,38 @@ 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 = { ...mockOfflineInterface,
+      const customMockOfflineInterface = {
+        ...mockOfflineInterface,
         latestIsConnected: false
       };
-
-      const customWrapper = (_ref4) => {
+      const customWrapper = _ref4 => {
         let {
           children
         } = _ref4;
         return /*#__PURE__*/React.createElement(OfflineProvider, {
           offlineInterface: customMockOfflineInterface
         }, children);
-      }; // render hook with custom wrapper
-
+      };
 
+      // render hook with custom wrapper
       renderHook(() => useDhis2ConnectionStatus(), {
         wrapper: customWrapper
-      }); // expect correct lastConnected time (mocked Date.now())
+      });
 
+      // expect correct lastConnected time (mocked Date.now())
       expect(localStorage.getItem(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(getLastConnectedKey(), testPreviousDate.toUTCString()); // render hook with custom wrapper
+      localStorage.setItem(getLastConnectedKey(), testPreviousDate.toUTCString());
 
-      const customMockOfflineInterface = { ...mockOfflineInterface,
+      // render hook with custom wrapper
+      const customMockOfflineInterface = {
+        ...mockOfflineInterface,
         latestIsConnected: false
       };
-
-      const customWrapper = (_ref5) => {
+      const customWrapper = _ref5 => {
         let {
           children
         } = _ref5;
@@ -665,29 +721,30 @@ describe('lastConnected status', () => {
           offlineInterface: customMockOfflineInterface
         }, children);
       };
-
       const {
         result
       } = renderHook(() => 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(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(getLastConnectedKey(), testPreviousDate.toUTCString()); // render hook with custom wrapper
+    localStorage.setItem(getLastConnectedKey(), testPreviousDate.toUTCString());
 
-    const customMockOfflineInterface = { ...mockOfflineInterface,
+    // render hook with custom wrapper
+    const customMockOfflineInterface = {
+      ...mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref6) => {
+    const customWrapper = _ref6 => {
       let {
         children
       } = _ref6;
@@ -706,26 +763,29 @@ describe('lastConnected status', () => {
         offlineInterface: customMockOfflineInterface
       }, children));
     };
-
     const {
       result
     } = renderHook(() => 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 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(getLastConnectedKey())).toBe(testPreviousDate.toUTCString());
 
-    expect(localStorage.getItem(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
     } = mockOfflineInterface.subscribeToDhis2ConnectionStatus.mock.calls[0][0];
@@ -733,8 +793,9 @@ describe('lastConnected status', () => {
       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 () => {
@@ -742,13 +803,14 @@ describe('lastConnected status', () => {
     const testAppName = 'test-app-name';
     const lastConnectedKey = 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 = { ...mockOfflineInterface,
+    // render hook with custom wrapper to start disconnected with app name
+    const customMockOfflineInterface = {
+      ...mockOfflineInterface,
       latestIsConnected: false
     };
-
-    const customWrapper = (_ref7) => {
+    const customWrapper = _ref7 => {
       let {
         children
       } = _ref7;
@@ -768,15 +830,16 @@ describe('lastConnected status', () => {
         offlineInterface: customMockOfflineInterface
       }, children));
     };
-
     const {
       result
     } = renderHook(() => 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);
 
+    // Go to connected then disconnected again to generate a new date
     await act(async () => {
       jest.runOnlyPendingTimers();
     });
@@ -787,15 +850,16 @@ describe('lastConnected status', () => {
     await 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;
@@ -815,7 +879,6 @@ describe("when the /api/ping endpoint isn't supported", () => {
       offlineInterface: mockOfflineInterface
     }, children));
   };
-
   test("pings aren't sent", async () => {
     const setTimeoutSpy = jest.spyOn(window, 'setTimeout');
     renderHook(() => useDhis2ConnectionStatus(), {
@@ -832,13 +895,14 @@ describe("when the /api/ping endpoint isn't supported", () => {
       result
     } = renderHook(() => useDhis2ConnectionStatus(), {
       wrapper: wrapper
-    }); // get onUpdate function passed to mockOfflineInterface
-
+    });
+    // get onUpdate function passed to mockOfflineInterface
     const {
       onUpdate
     } = 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);
 
+    // Trigger connection status change from offline interface
     await act(async () => {
       onUpdate({
         isConnected: false