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

package/build/cjs/lib/__tests__/offline-provider.test.js

@@ -1,44 +1,35 @@
 "use strict";
 
 var _react = require("@testing-library/react");
-
 var _react2 = _interopRequireDefault(require("react"));
-
 var _testMocks = require("../../utils/test-mocks");
-
 var _cacheableSection = require("../cacheable-section");
-
 var _cacheableSectionState = require("../cacheable-section-state");
-
 var _offlineProvider = require("../offline-provider");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Suppress 'act' warning for these tests
 const originalError = console.error;
 beforeEach(() => {
   jest.spyOn(console, 'error').mockImplementation(function () {
     const pattern = /Warning: An update to .* inside a test was not wrapped in act/;
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     if (typeof args[0] === 'string' && pattern.test(args[0])) {
       return;
     }
-
     return originalError.call(console, ...args);
   });
 });
 afterEach(() => {
-  jest.clearAllMocks() // syntax needed to appease typescript
+  jest.clearAllMocks()
+  // syntax needed to appease typescript
   ;
   console.error.mockRestore();
 });
 describe('Testing offline provider', () => {
   it('Should render without failing', () => {
-    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+    (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: _testMocks.mockOfflineInterface
     }, /*#__PURE__*/_react2.default.createElement("div", {
       "data-testid": "test-div"
@@ -46,7 +37,8 @@ describe('Testing offline provider', () => {
     expect(_react.screen.getByTestId('test-div')).toBeInTheDocument();
   });
   it('Should sync cached sections with indexedDB', async () => {
-    const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    const testOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       getCachedSections: jest.fn().mockResolvedValue([{
         sectionId: '1',
         lastUpdated: 'date1'
@@ -55,7 +47,6 @@ describe('Testing offline provider', () => {
         lastUpdated: 'date2'
       }])
     };
-
     const CachedSections = () => {
       const {
         cachedSections
@@ -64,8 +55,7 @@ describe('Testing offline provider', () => {
         "data-testid": "sections"
       }, JSON.stringify(cachedSections));
     };
-
-    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+    (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: testOfflineInterface
     }, /*#__PURE__*/_react2.default.createElement(CachedSections, null)));
     const {
@@ -93,23 +83,23 @@ describe('Testing offline provider', () => {
         "data-testid": "test-div"
       }));
     };
-
-    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+    (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: _testMocks.mockOfflineInterface
     }, /*#__PURE__*/_react2.default.createElement(TestConsumer, null)));
     expect(_react.screen.getByTestId('test-div')).toBeInTheDocument();
   });
   it('Should render without failing when no offlineInterface is provided', () => {
-    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, null, /*#__PURE__*/_react2.default.createElement("div", {
+    (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, null, /*#__PURE__*/_react2.default.createElement("div", {
       "data-testid": "test-div"
     })));
     expect(_react.screen.getByTestId('test-div')).toBeInTheDocument();
   });
   it('Should render without failing if PWA is not enabled', () => {
-    const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+    const testOfflineInterface = {
+      ..._testMocks.mockOfflineInterface,
       pwaEnabled: false
     };
-    (0, _react.render)( /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+    (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: testOfflineInterface
     }, /*#__PURE__*/_react2.default.createElement("div", {
       "data-testid": "test-div"

package/build/cjs/lib/__tests__/use-cacheable-section.test.js

@@ -1,52 +1,43 @@
 "use strict";
 
-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 _cacheableSection = require("../cacheable-section");
-
 var _offlineProvider = require("../offline-provider");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Suppress 'act' warning for these tests
 const originalError = console.error;
 beforeEach(() => {
   jest.spyOn(console, 'error').mockImplementation(function () {
     const pattern = /Warning: An update to .* inside a test was not wrapped in act/;
-
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     if (typeof args[0] === 'string' && pattern.test(args[0])) {
       return;
     }
-
     return originalError.call(console, ...args);
   });
 });
 afterEach(() => {
-  jest.clearAllMocks() // This syntax appeases typescript:
+  jest.clearAllMocks()
+  // This syntax appeases typescript:
   ;
   console.error.mockRestore();
 });
 it('renders in the default state initially', () => {
-  const wrapper = (_ref) => {
+  const wrapper = _ref => {
     let {
       children
     } = _ref;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: _testMocks.mockOfflineInterface
     }, children);
   };
-
   const {
     result
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
     wrapper
   });
   expect(result.current.recordingState).toBe('default');
@@ -54,19 +45,18 @@ it('renders in the default state initially', () => {
   expect(result.current.lastUpdated).toBeUndefined();
 });
 it('has stable references', () => {
-  const wrapper = (_ref2) => {
+  const wrapper = _ref2 => {
     let {
       children
     } = _ref2;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
       offlineInterface: _testMocks.mockOfflineInterface
     }, children);
   };
-
   const {
     result,
     rerender
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
     wrapper
   });
   const origRecordingState = result.current.recordingState;
@@ -83,61 +73,67 @@ it('has stable references', () => {
 });
 it('handles a successful recording', async done => {
   const [sectionId, timeoutDelay] = ['one', 1234];
-  const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+  const recordingSuccessOfflineInterface = {
+    ..._testMocks.mockOfflineInterface,
     getCachedSections: jest.fn().mockResolvedValueOnce([]).mockResolvedValueOnce([{
       sectionId: sectionId,
       lastUpdated: new Date()
     }])
   };
-
-  const wrapper = (_ref3) => {
+  const wrapper = _ref3 => {
     let {
       children
     } = _ref3;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: testOfflineInterface
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: recordingSuccessOfflineInterface
     }, children);
   };
-
   const {
-    result,
-    waitFor
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)(sectionId), {
+    result
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)(sectionId), {
     wrapper
   });
-
   const assertRecordingStarted = () => {
     expect(result.current.recordingState).toBe('recording');
   };
-
   const assertRecordingCompleted = async () => {
-    expect(result.current.recordingState).toBe('default'); // Test that 'isCached' gets updated
-
-    expect(testOfflineInterface.getCachedSections).toBeCalledTimes(2);
-    await waitFor(() => result.current.isCached === true);
+    expect(result.current.recordingState).toBe('default');
+
+    // Test that 'isCached' gets updated
+    expect(recordingSuccessOfflineInterface.getCachedSections).toBeCalledTimes(2);
+    // Recording states are updated synchronously, but getting isCached
+    // state is asynchronous -- need to wait for that here.
+    // An assertion is not used as the waitFor condition because it may skew
+    // the total number assertions in this test if it needs to retry. Number
+    // of assertions is checked at the bottom of this test to make sure both
+    // of these callbacks are called.
+    await (0, _react.waitFor)(() => result.current.isCached === true);
     expect(result.current.isCached).toBe(true);
-    expect(result.current.lastUpdated).toBeInstanceOf(Date); // If this cb is not called, test should time out and fail
+    expect(result.current.lastUpdated).toBeInstanceOf(Date);
 
+    // If this cb is not called, test should time out and fail
     done();
   };
-
-  await (0, _reactHooks.act)(async () => {
+  await (0, _react.act)(async () => {
     await result.current.startRecording({
       onStarted: assertRecordingStarted,
       onCompleted: assertRecordingCompleted,
       recordingTimeoutDelay: timeoutDelay
     });
-  }); // At this stage, recording should be 'pending'
+  });
 
-  expect(result.current.recordingState).toBe('pending'); // Check correct options sent to offline interface
+  // At this stage, recording should be 'pending'
+  expect(result.current.recordingState).toBe('pending');
 
+  // Check correct options sent to offline interface
   const options = _testMocks.mockOfflineInterface.startRecording.mock.calls[0][0];
   expect(options.sectionId).toBe(sectionId);
   expect(options.recordingTimeoutDelay).toBe(timeoutDelay);
   expect(typeof options.onStarted).toBe('function');
   expect(typeof options.onCompleted).toBe('function');
-  expect(typeof options.onError).toBe('function'); // Make sure all async assertions are called
+  expect(typeof options.onError).toBe('function');
 
+  // Make sure all async assertions are called
   expect.assertions(11);
 });
 it('handles a recording that encounters an error', async done => {
@@ -145,81 +141,75 @@ it('handles a recording that encounters an error', async done => {
   jest.spyOn(console, 'error').mockImplementation(function () {
     const actPattern = /Warning: An update to .* inside a test was not wrapped in act/;
     const errPattern = /Error during recording/;
-
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
-
     const matchesPattern = actPattern.test(args[0]) || errPattern.test(args[0]);
-
     if (typeof args[0] === 'string' && matchesPattern) {
       return;
     }
-
     return originalError.call(console, ...args);
   });
-  const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+  const recordingErrorOfflineInterface = {
+    ..._testMocks.mockOfflineInterface,
     startRecording: _testMocks.errorRecordingMock
   };
-
-  const wrapper = (_ref4) => {
+  const wrapper = _ref4 => {
     let {
       children
     } = _ref4;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: testOfflineInterface
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: recordingErrorOfflineInterface
     }, children);
   };
-
   const {
     result
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)('one'), {
     wrapper
   });
-
   const assertRecordingStarted = () => {
     expect(result.current.recordingState).toBe('recording');
   };
-
   const assertRecordingError = error => {
     expect(result.current.recordingState).toBe('error');
     expect(error.message).toMatch(/test err/); // see errorRecordingMock
+    expect(console.error).toHaveBeenCalledWith('Error during recording:', error);
 
-    expect(console.error).toHaveBeenCalledWith('Error during recording:', error); // Expect only one call, from initialization:
-
-    expect(_testMocks.mockOfflineInterface.getCachedSections).toBeCalledTimes(1); // If this cb is not called, test should time out and fail
+    // Expect only one call, from initialization:
+    expect(_testMocks.mockOfflineInterface.getCachedSections).toBeCalledTimes(1);
 
+    // If this cb is not called, test should time out and fail
     done();
   };
-
-  await (0, _reactHooks.act)(async () => {
+  await (0, _react.act)(async () => {
     await result.current.startRecording({
       onStarted: assertRecordingStarted,
       onError: assertRecordingError
     });
-  }); // At this stage, recording should be 'pending'
+  });
 
-  expect(result.current.recordingState).toBe('pending'); // Make sure all async assertions are called
+  // At this stage, recording should be 'pending'
+  expect(result.current.recordingState).toBe('pending');
 
+  // Make sure all async assertions are called
   expect.assertions(6);
 });
 it('handles an error starting the recording', async () => {
-  const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+  const messageErrorOfflineInterface = {
+    ..._testMocks.mockOfflineInterface,
     startRecording: _testMocks.failedMessageRecordingMock
   };
-
-  const wrapper = (_ref5) => {
+  const wrapper = _ref5 => {
     let {
       children
     } = _ref5;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: testOfflineInterface
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: messageErrorOfflineInterface
     }, children);
   };
-
   const {
     result
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)('err'), {
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)('err'), {
     wrapper
   });
   await expect(result.current.startRecording()).rejects.toThrow('Failed message' // from failedMessageRecordingMock
@@ -227,72 +217,71 @@ it('handles an error starting the recording', async () => {
 });
 it('handles remove and updates sections', async () => {
   const sectionId = 'one';
-  const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+  const sectionOpsOfflineInterface = {
+    ..._testMocks.mockOfflineInterface,
     getCachedSections: jest.fn().mockResolvedValueOnce([{
       sectionId: sectionId,
       lastUpdated: new Date()
     }]).mockResolvedValueOnce([])
   };
-
-  const wrapper = (_ref6) => {
+  const wrapper = _ref6 => {
     let {
       children
     } = _ref6;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: testOfflineInterface
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: sectionOpsOfflineInterface
     }, children);
   };
-
   const {
-    result,
-    waitFor
-  } = (0, _reactHooks.renderHook)(() => (0, _cacheableSection.useCacheableSection)(sectionId), {
+    result
+  } = (0, _react.renderHook)(() => (0, _cacheableSection.useCacheableSection)(sectionId), {
     wrapper
-  }); // Wait for state to sync with indexedDB
+  });
 
-  await waitFor(() => result.current.isCached === true);
+  // Wait for state to sync with indexedDB
+  await (0, _react.waitFor)(() => expect(result.current.isCached).toBe(true));
   let success;
-  await (0, _reactHooks.act)(async () => {
+  await (0, _react.act)(async () => {
     success = await result.current.remove();
   });
-  expect(success).toBe(true); // Test that 'isCached' gets updated
-
-  expect(testOfflineInterface.getCachedSections).toBeCalledTimes(2);
-  await waitFor(() => result.current.isCached === false);
+  expect(success).toBe(true);
+  // Test that 'isCached' gets updated
+  expect(sectionOpsOfflineInterface.getCachedSections).toBeCalledTimes(2);
+  await (0, _react.waitFor)(() => expect(result.current.isCached).toBe(false));
   expect(result.current.isCached).toBe(false);
   expect(result.current.lastUpdated).toBeUndefined();
 });
 it('handles a change in ID', async () => {
-  const testOfflineInterface = { ..._testMocks.mockOfflineInterface,
+  const idChangeOfflineInterface = {
+    ..._testMocks.mockOfflineInterface,
     getCachedSections: jest.fn().mockResolvedValue([{
       sectionId: 'id-one',
       lastUpdated: new Date()
     }])
   };
-
-  const wrapper = (_ref7) => {
+  const wrapper = _ref7 => {
     let {
       children
     } = _ref7;
-    return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
-      offlineInterface: testOfflineInterface
+    return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
+      offlineInterface: idChangeOfflineInterface
     }, children);
   };
-
   const {
     result,
-    waitFor,
     rerender
-  } = (0, _reactHooks.renderHook)(id => (0, _cacheableSection.useCacheableSection)(id), {
+  } = (0, _react.renderHook)(id => (0, _cacheableSection.useCacheableSection)(id), {
     wrapper,
     initialProps: 'id-one'
-  }); // Wait for state to sync with indexedDB
+  });
 
-  await waitFor(() => result.current.isCached === true);
-  rerender('id-two'); // Test that 'isCached' gets updated
-  // expect(testOfflineInterface.getCachedSections).toBeCalledTimes(2)
+  // Wait for state to sync with indexedDB
+  await (0, _react.waitFor)(() => expect(result.current.isCached).toBe(true));
+  rerender('id-two');
 
-  await waitFor(() => result.current.isCached === false);
+  // Test that 'isCached' gets updated
+  // expect(idChangeOfflineInterface.getCachedSections).toBeCalledTimes(2)
+  await (0, _react.waitFor)(() => expect(result.current.isCached).toBe(false));
   expect(result.current.isCached).toBe(false);
   expect(result.current.lastUpdated).toBeUndefined();
 });

package/build/cjs/lib/__tests__/use-online-status-message.test.js

@@ -1,35 +1,28 @@
 "use strict";
 
-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 _onlineStatusMessage = require("../online-status-message");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 describe('useOnlineStatusMessage', () => {
   it('should allow the online status to be updated ', () => {
-    const wrapper = (_ref) => {
+    const wrapper = _ref => {
       let {
         children
       } = _ref;
-      return /*#__PURE__*/_react.default.createElement(_offlineProvider.OfflineProvider, {
+      return /*#__PURE__*/_react2.default.createElement(_offlineProvider.OfflineProvider, {
         offlineInterface: _testMocks.mockOfflineInterface
       }, children);
     };
-
     const {
       result
-    } = (0, _reactHooks.renderHook)(() => (0, _onlineStatusMessage.useOnlineStatusMessage)(), {
+    } = (0, _react.renderHook)(() => (0, _onlineStatusMessage.useOnlineStatusMessage)(), {
       wrapper
     });
     expect(result.current.onlineStatusMessage).toBeUndefined();
-    (0, _reactHooks.act)(() => {
+    (0, _react.act)(() => {
       result.current.setOnlineStatusMessage('8 offline events');
     });
     expect(result.current.onlineStatusMessage).toEqual('8 offline events');