@dhis2/app-service-data 3.2.4 → 3.2.8

package/build/es/__tests__/integration.test.js

@@ -1,8 +1,8 @@
 import { render, waitFor } from '@testing-library/react';
 import * as React from 'react';
 import { CustomDataProvider, DataQuery } from '../react';
-describe('Testing custom data provider and useQuery hook', () => {
-  it('Should render without failing', async () => {
+describe('<DataQuery />', () => {
+  it('should render without failing', async () => {
     const data = {
       answer: 42
     };
@@ -13,18 +13,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.answer);
-    });
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataQuery, {
       query: {
         answer: {
           resource: 'answer'
@@ -33,24 +23,21 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await waitFor(() => {
-      getByText(/data: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        data
+      }));
     });
-    expect(getByText(/data: /i)).toHaveTextContent("data: ".concat(data.answer));
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      data
-    }));
   });
-  it('Should render an error', async () => {
+  it('should render an error', async () => {
     const expectedError = new Error('Something went wrong');
     const data = {
       test: () => {
@@ -64,18 +51,8 @@ describe('Testing custom data provider and useQuery hook', () => {
       data: data
     }, children);
 
-    const renderFunction = jest.fn(({
-      loading,
-      error,
-      data
-    }) => {
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      return /*#__PURE__*/React.createElement("div", null, "data: ", data && data.test);
-    });
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(DataQuery, {
+    const renderFunction = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataQuery, {
       query: {
         test: {
           resource: 'test'
@@ -84,21 +61,18 @@ describe('Testing custom data provider and useQuery hook', () => {
     }, renderFunction), {
       wrapper
     });
-    expect(getByText(/loading/i)).not.toBeUndefined();
     expect(renderFunction).toHaveBeenCalledTimes(1);
     expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
       called: true,
       loading: true
     }));
     await waitFor(() => {
-      getByText(/error: /i);
+      expect(renderFunction).toHaveBeenCalledTimes(2);
+      expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
+        called: true,
+        loading: false,
+        error: expectedError
+      }));
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(getByText(/error: /i)).toHaveTextContent("error: ".concat(expectedError.message));
-    expect(renderFunction).toHaveBeenLastCalledWith(expect.objectContaining({
-      called: true,
-      loading: false,
-      error: expectedError
-    }));
   });
 });

package/build/es/__tests__/mutations.test.js

@@ -1,76 +1,65 @@
-import { render, act, waitFor } from '@testing-library/react';
-import React from 'react';
+import { render, waitFor, act } from '@testing-library/react';
+import * as React from 'react';
 import { CustomDataProvider, DataMutation } from '../react';
-const mockBackend = {
-  target: jest.fn((type, query) => {
-    expect(query.resource).toBe('target');
-    expect(type).toBe('create');
-    expect(query.data).toMatchObject({
-      question: '?'
-    });
-    return Promise.resolve({
-      answer: 42
-    });
-  })
-};
-describe('Test mutations', () => {
-  it('Should call the mock callback', async () => {
-    let doMutation;
-    const renderFunction = jest.fn(([mutate, {
-      called,
-      loading,
-      error,
-      data
-    }]) => {
-      doMutation = mutate;
-      if (!called) return 'uncalled';
-      if (loading) return 'loading';
-      if (error) return /*#__PURE__*/React.createElement("div", null, "error: ", error.message);
-      if (data) return /*#__PURE__*/React.createElement("div", null, "data: ", data.answer);
-    });
-    const testMutation = {
-      resource: 'target',
+describe('<DataMutation />', () => {
+  it('should render without failing', async () => {
+    const endpointSpy = jest.fn(() => Promise.resolve(42));
+    const mutation = {
+      resource: 'answer',
       type: 'create',
       data: {
         question: '?'
       }
     };
-    const {
-      getByText
-    } = render( /*#__PURE__*/React.createElement(CustomDataProvider, {
-      data: mockBackend
-    }, /*#__PURE__*/React.createElement(DataMutation, {
-      mutation: testMutation
-    }, renderFunction)));
-    expect(getByText(/uncalled/i)).not.toBeUndefined();
-    expect(renderFunction).toHaveBeenCalledTimes(1);
-    expect(mockBackend.target).not.toHaveBeenCalled();
-    expect(renderFunction).toHaveBeenLastCalledWith([expect.any(Function), {
+    const data = {
+      answer: endpointSpy
+    };
+
+    const wrapper = ({
+      children
+    }) => /*#__PURE__*/React.createElement(CustomDataProvider, {
+      data: data
+    }, children);
+
+    const renderSpy = jest.fn(() => null);
+    render( /*#__PURE__*/React.createElement(DataMutation, {
+      mutation: mutation
+    }, renderSpy), {
+      wrapper
+    });
+    expect(endpointSpy).toHaveBeenCalledTimes(0);
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
       called: false,
       loading: false,
       engine: expect.any(Object)
-    }]);
-    expect(doMutation).not.toBeUndefined();
-    act(() => {
-      doMutation && doMutation();
+    })]);
+    await act(async () => {
+      const firstRenderSpyCall = renderSpy.mock.calls[0];
+      const firstRenderSpyArgument = firstRenderSpyCall[0];
+      const [mutate] = firstRenderSpyArgument;
+      await mutate();
+    });
+    waitFor(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(2);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: true,
+        engine: expect.any(Object)
+      })]);
+    });
+    waitFor(() => {
+      expect(endpointSpy).toHaveBeenCalledTimes(1);
+      expect(renderSpy).toHaveBeenCalledTimes(3);
+      expect(renderSpy).toHaveBeenLastCalledWith([expect.any(Function), expect.objectContaining({
+        called: true,
+        loading: false,
+        data: {
+          answer: 42
+        },
+        engine: expect.any(Object)
+      })]);
     });
-    expect(renderFunction).toHaveBeenCalledTimes(2);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: true,
-      engine: expect.any(Object)
-    }]);
-    expect(mockBackend.target).toHaveBeenCalledTimes(1);
-    await waitFor(() => getByText(/data: /i));
-    expect(renderFunction).toHaveBeenCalledTimes(3);
-    expect(renderFunction).toHaveBeenLastCalledWith([doMutation, {
-      called: true,
-      loading: false,
-      data: {
-        answer: 42
-      },
-      engine: expect.any(Object)
-    }]);
-    expect(getByText(/data: /i)).toHaveTextContent("data: 42");
   });
 });

package/build/es/links/RestAPILink/queryToRequestOptions/textPlainMatchers.js

@@ -18,25 +18,32 @@ export const isReplyToMessageConversation = (type, {
 
 export const isCreateFeedbackMessage = (type, {
   resource
-}) => type === 'create' && resource === 'messageConversations/feedback'; // POST or PUT to `interpretations/${objectType}/${id}` (add or update an interpretation)
+}) => type === 'create' && resource === 'messageConversations/feedback'; // POST `interpretations/${objectType}/${id}` (add an interpretation to a visualization)
 
-export const isCreateOrUpdateInterpretation = (type, {
+export const isCreateInterpretation = (type, {
+  resource
+}) => {
+  const pattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventVisualization|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  return type === 'create' && pattern.test(resource);
+}; // PUT to `interpretations/${id}` (update an interpretation)
+
+export const isUpdateInterpretation = (type, {
   resource,
   id
 }) => {
-  if (type !== 'create' && type !== 'replace') {
+  if (type !== 'replace') {
     return false;
   }
 
   let resourcePattern;
 
-  if (type === 'replace' && id) {
-    resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)$/;
+  if (id) {
+    resourcePattern = /^interpretations$/;
     const idPattern = /^[a-zA-Z0-9]{11}$/;
     return resourcePattern.test(resource) && idPattern.test(id);
   }
 
-  resourcePattern = /^interpretations\/(?:reportTable|chart|visualization|map|eventReport|eventChart|dataSetReport)\/[a-zA-Z0-9]{11}$/;
+  resourcePattern = /^interpretations\/[a-zA-Z0-9]{11}$/;
   return resourcePattern.test(resource);
 }; // POST to `interpretations/${id}/comments` (comment on an interpretation)
 

package/build/es/links/RestAPILink/queryToRequestOptions/textPlainMatchers.test.js

@@ -1,4 +1,4 @@
-import { isReplyToMessageConversation, isCreateFeedbackMessage, isCreateOrUpdateInterpretation, isCommentOnInterpretation, isInterpretationCommentUpdate, isAddOrUpdateSystemOrUserSetting, addOrUpdateConfigurationProperty, isMetadataPackageInstallation } from './textPlainMatchers';
+import { isReplyToMessageConversation, isCreateFeedbackMessage, isCreateInterpretation, isUpdateInterpretation, isCommentOnInterpretation, isInterpretationCommentUpdate, isAddOrUpdateSystemOrUserSetting, addOrUpdateConfigurationProperty, isMetadataPackageInstallation } from './textPlainMatchers';
 describe('isReplyToMessageConversation', () => {
   it('retuns true for POST to `messageConversations/${id}`', () => {
     expect(isReplyToMessageConversation('create', {
@@ -23,30 +23,58 @@ describe('isCreateFeedbackMessage', () => {
     })).toEqual(false);
   });
 });
-describe('isCreateOrUpdateInterpretation', () => {
+describe('isCreateInterpretation', () => {
   it('returns true for a POST to "interpretations/chart/${id}"', () => {
-    expect(isCreateOrUpdateInterpretation('create', {
+    expect(isCreateInterpretation('create', {
       resource: 'interpretations/chart/oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('returns true for a PUT to "interpretations/chart/${id}"', () => {
-    expect(isCreateOrUpdateInterpretation('replace', {
+  it('returns false for a PUT to "interpretations/chart/${id}"', () => {
+    expect(isCreateInterpretation('replace', {
       resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('retuns false for PATCH requests with a valid query', () => {
+    expect(isCreateInterpretation('update', {
+      resource: 'interpretations/chart/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a request to a different resource', () => {
+    expect(isCreateInterpretation('create', {
+      resource: 'interpretations/dummy/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+});
+describe('isUpdateInterpretation', () => {
+  it('returns true for a PUT to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('replace', {
+      resource: 'interpretations/oXD88WWSQpR'
     })).toEqual(true);
   });
   it('returns true for PUT with populated query.id', () => {
-    expect(isCreateOrUpdateInterpretation('replace', {
-      resource: 'interpretations/chart',
+    expect(isUpdateInterpretation('replace', {
+      resource: 'interpretations',
       id: 'oXD88WWSQpR'
     })).toEqual(true);
   });
-  it('retuns false for PATCH requests with a valid query', () => {
-    expect(isCreateOrUpdateInterpretation('update', {
-      resource: 'interpretations/chart/oXD88WWSQpR'
+  it('returns false for a POST to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('create', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for a PATCH to "interpretations/${id}"', () => {
+    expect(isUpdateInterpretation('update', {
+      resource: 'interpretations/oXD88WWSQpR'
+    })).toEqual(false);
+  });
+  it('returns false for PATCH with populated query.id', () => {
+    expect(isUpdateInterpretation('update', {
+      resource: 'interpretations',
+      id: 'oXD88WWSQpR'
     })).toEqual(false);
   });
   it('returns false for a request to a different resource', () => {
-    expect(isCreateOrUpdateInterpretation('create', {
+    expect(isUpdateInterpretation('create', {
       resource: 'interpretations/dummy/oXD88WWSQpR'
     })).toEqual(false);
   });