@k-int/stripes-kint-components 5.36.1 → 5.37.0

package/src/lib/hooks/useMutateCustomProperties/useMutateCustomProperties.test.js

@@ -0,0 +1,65 @@
+import { renderHook } from '@folio/jest-config-stripes/testing-library/react';
+
+import useMutateGeneric from '../useMutateGeneric';
+import useMutateCustomProperties from './useMutateCustomProperties';
+
+// Use file in __mocks__
+jest.mock('../useMutateGeneric');
+
+describe('useMutateCustomProperties', () => {
+  const mockEndpoint = 'test/endpoint';
+  const mockId = '12345';
+
+  beforeEach(() => {
+    useMutateGeneric.mockClear();
+  });
+
+  describe('initialization', () => {
+    let sentConfig;
+    beforeEach(() => {
+      renderHook(() => useMutateCustomProperties({
+        endpoint: mockEndpoint,
+        id: mockId,
+        extraProp: 'passed-through'
+      }));
+
+      sentConfig = useMutateGeneric.mock.calls[0][0];
+    });
+
+    test('calls useMutateGeneric', () => {
+      expect(useMutateGeneric).toHaveBeenCalled();
+    });
+
+    test('passes the correct endpoint', () => {
+      expect(sentConfig.endpoint).toBe(mockEndpoint);
+    });
+
+    test('passes the id through', () => {
+      expect(sentConfig.id).toBe(mockId);
+    });
+
+    test('passes through additional mutateGenericProps', () => {
+      expect(sentConfig.extraProp).toBe('passed-through');
+    });
+
+    test('constructs the correct domain-specific queryKey', () => {
+      expect(sentConfig.queryKey).toEqual([
+        'stripes-kint-components',
+        'useMutateCustomProperties',
+        mockId
+      ]);
+    });
+
+    describe('endpointMutators logic', () => {
+      test('defines a delete mutator that appends the id to the endpoint', () => {
+        // This triggers the code: () => `${endpoint}/${id}`
+        expect(sentConfig.endpointMutators.delete()).toBe(`${mockEndpoint}/${mockId}`);
+      });
+
+      test('defines a put mutator that appends the id to the endpoint', () => {
+        // This triggers the code: () => `${endpoint}/${id}`
+        expect(sentConfig.endpointMutators.put()).toBe(`${mockEndpoint}/${mockId}`);
+      });
+    });
+  });
+});

package/src/lib/hooks/useMutateGeneric/useMutateGeneric.test.js

@@ -0,0 +1,194 @@
+import { useMutation } from 'react-query';
+
+// EXAMPLE -- Using the mockKy spies from useOkapiKy mock
+import { mockDelete, mockPut, mockPost, mockKyJson } from '@folio/stripes/core';
+import { renderHook, waitFor } from '@folio/jest-config-stripes/testing-library/react';
+
+import useMutateGeneric from './useMutateGeneric';
+
+describe('useMutateGeneric', () => {
+  const mockEndpoint = 'test/endpoint';
+  const mockQueryKey = ['test', 'key'];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe.each([
+    {
+      verb: 'delete',
+      callIndex: 0,
+      payload: '12345',
+      expectedKeySuffix: 'delete',
+      expectedUrl: 'test/endpoint/12345',
+      mockSpy: mockDelete,
+    },
+    {
+      verb: 'put',
+      callIndex: 1,
+      payload: { id: '12345', name: 'test' },
+      expectedKeySuffix: 'edit',
+      expectedUrl: 'test/endpoint/12345',
+      expectedPayload: {
+        json: {
+          id: '12345',
+          name: 'test'
+        }
+      },
+      mockSpy: mockPut,
+    },
+    {
+      verb: 'post',
+      callIndex: 2,
+      payload: { name: 'new test' },
+      expectedKeySuffix: 'create',
+      expectedUrl: 'test/endpoint',
+      expectedPayload: {
+        json: {
+          name: 'new test'
+        }
+      },
+      mockSpy: mockPost,
+    },
+  ])('Verb: $verb', ({
+    verb,
+    callIndex,
+    payload,
+    expectedKeySuffix,
+    expectedUrl,
+    expectedPayload,
+    mockSpy
+  }) => {
+    describe(`initialization for ${verb}`, () => {
+      let hookResult;
+      beforeEach(() => {
+        const { result } = renderHook(() => useMutateGeneric({
+          endpoint: mockEndpoint,
+          queryKey: mockQueryKey,
+        }));
+        hookResult = result;
+      });
+
+      test(`returns the ${verb} mutation function`, () => {
+        expect(typeof hookResult.current[verb]).toBe('function');
+      });
+
+      test(`configures useMutation with the correct ${verb} queryKey`, () => {
+        // useMutation call index: 0=delete, 1=put, 2=post
+        expect(useMutation.mock.calls[callIndex][0]).toEqual([...mockQueryKey, expectedKeySuffix]);
+      });
+    });
+
+    describe(`with returnQueryObject: true, return full mutation object for ${verb}`, () => {
+      let hookResult;
+      beforeEach(() => {
+        const { result } = renderHook(() => useMutateGeneric({
+          endpoint: mockEndpoint,
+          returnQueryObject: { [verb]: true }
+        }));
+        hookResult = result;
+      });
+
+      test(`returns the full mutation object for ${verb} when requested`, () => {
+        expect(hookResult.current[verb]).toHaveProperty('mutateAsync');
+      });
+    });
+
+    describe(`execution for ${verb}`, () => {
+      const afterCall = jest.fn();
+      const catchCall = jest.fn();
+      const customMutator = jest.fn((p) => (verb === 'post' ? 'custom/post' : `custom/${p?.id || p}`));
+
+      describe('successful lifecycle', () => {
+        const successData = { id: 'some-id' };
+
+        beforeEach(async () => {
+          mockKyJson.mockResolvedValueOnce(successData);
+
+          const { result } = renderHook(() => useMutateGeneric({
+            endpoint: mockEndpoint,
+            afterQueryCalls: { [verb]: afterCall },
+            endpointMutators: { [verb]: customMutator },
+          }));
+
+          await waitFor(async () => {
+            await result.current[verb](payload);
+          });
+        });
+
+        test('calls the custom endpointMutator', () => {
+          expect(customMutator).toHaveBeenCalledWith(payload);
+        });
+
+        test('calls the correct ky verb with the mutated URL', () => {
+          const expectedCustomUrl = verb === 'post' ? 'custom/post' : 'custom/12345';
+
+          if (expectedPayload) {
+            expect(mockSpy).toHaveBeenCalledWith(expectedCustomUrl, expectedPayload);
+          } else {
+            expect(mockSpy).toHaveBeenCalledWith(expectedCustomUrl);
+          }
+        });
+
+        test('executes the afterQuery success callback', () => {
+          expect(afterCall).toHaveBeenCalledWith(successData);
+        });
+      });
+
+      describe('failure lifecycle', () => {
+        beforeEach(async () => {
+          mockSpy.mockImplementationOnce(() => ({
+            json: () => Promise.reject(new Error('Network Error')),
+          }));
+
+          const { result } = renderHook(() => useMutateGeneric({
+            endpoint: mockEndpoint,
+            catchQueryCalls: { [verb]: catchCall },
+          }));
+
+          await waitFor(async () => {
+            try {
+              await result.current[verb](payload);
+            } catch (e) { /* error handled in hook */ }
+          });
+        });
+
+        test('executes the catchQuery failure callback', () => {
+          expect(catchCall).toHaveBeenCalled();
+        });
+      });
+
+      describe('default mutators fallback', () => {
+        beforeEach(async () => {
+          const { result } = renderHook(() => useMutateGeneric({ endpoint: mockEndpoint }));
+          await waitFor(async () => {
+            await result.current[verb](payload);
+          });
+        });
+
+        test('uses default URL construction logic', () => {
+          if (expectedPayload) {
+            expect(mockSpy).toHaveBeenCalledWith(expectedUrl, expectedPayload);
+          } else {
+            expect(mockSpy).toHaveBeenCalledWith(expectedUrl);
+          }
+        });
+      });
+    });
+
+    describe(`returnQueryObject toggle for ${verb}`, () => {
+      let hookResult;
+      beforeEach(() => {
+        const { result } = renderHook(() => useMutateGeneric({
+          endpoint: mockEndpoint,
+          returnQueryObject: { [verb]: true }
+        }));
+        hookResult = result;
+      });
+
+      test('returns the full mutation object', () => {
+        expect(hookResult.current[verb]).toHaveProperty('mutateAsync');
+      });
+    });
+  });
+});

package/src/lib/hooks/useMutateRefdataCategory/useMutateRefdataCategory.test.js

@@ -0,0 +1,76 @@
+import { renderHook } from '@folio/jest-config-stripes/testing-library/react';
+import useMutateGeneric from '../useMutateGeneric';
+import useInvalidateRefdata from '../useInvalidateRefdata';
+import useMutateRefdataCategory from './useMutateRefdataCategory';
+
+// Mocking dependencies
+jest.mock('../useMutateGeneric');
+jest.mock('../useInvalidateRefdata');
+
+describe('useMutateRefdataCategory', () => {
+  const mockEndpoint = 'erm/refdata';
+  const mockInvalidate = jest.fn(() => Promise.resolve());
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useInvalidateRefdata.mockReturnValue(mockInvalidate);
+  });
+
+  describe('initialization', () => {
+    let sentConfig;
+    beforeEach(() => {
+      renderHook(() => useMutateRefdataCategory({
+        endpoint: mockEndpoint
+      }));
+      sentConfig = useMutateGeneric.mock.calls[0][0];
+    });
+
+    test('passes the correct endpoint', () => {
+      expect(sentConfig.endpoint).toBe(mockEndpoint);
+    });
+
+    test('constructs the correct queryKey', () => {
+      expect(sentConfig.queryKey).toEqual([
+        'stripes-kint-components',
+        'useMutateRefdataCategory'
+      ]);
+    });
+
+    test('payloadMutator for post adds an empty values array', () => {
+      const result = sentConfig.payloadMutators.post({ desc: 'new category' });
+      expect(result.json).toEqual({
+        desc: 'new category',
+        values: []
+      });
+    });
+  });
+
+  describe('afterQueryCalls lifecycle', () => {
+    const mockRes = { id: '123' };
+    let sentConfig;
+
+    describe.each(['delete', 'post', 'put'])('Verb: %s', (verb) => {
+      const externalCallback = jest.fn();
+
+      beforeEach(async () => {
+        renderHook(() => useMutateRefdataCategory({
+          endpoint: mockEndpoint,
+          afterQueryCalls: { [verb]: externalCallback }
+        }));
+
+        sentConfig = useMutateGeneric.mock.calls[0][0];
+
+        // Manually trigger the wrapper function defined in the hook
+        await sentConfig.afterQueryCalls[verb](mockRes);
+      });
+
+      test(`calls invalidateRefdata for ${verb}`, () => {
+        expect(mockInvalidate).toHaveBeenCalled();
+      });
+
+      test(`calls the provided afterQuery${verb.charAt(0).toUpperCase() + verb.slice(1)} callback`, () => {
+        expect(externalCallback).toHaveBeenCalledWith(mockRes);
+      });
+    });
+  });
+});

package/src/lib/hooks/useMutateRefdataValue/useMutateRefdataValue.test.js

@@ -0,0 +1,93 @@
+import { renderHook } from '@folio/jest-config-stripes/testing-library/react';
+import useMutateGeneric from '../useMutateGeneric';
+import useInvalidateRefdata from '../useInvalidateRefdata';
+import useMutateRefdataValue from './useMutateRefdataValue';
+
+jest.mock('../useMutateGeneric');
+jest.mock('../useInvalidateRefdata');
+
+describe('useMutateRefdataValue', () => {
+  const mockEndpoint = 'erm/refdata/values';
+  const mockId = 'category-123';
+  const mockInvalidate = jest.fn(() => Promise.resolve());
+  const mockKy = {
+    put: jest.fn(() => ({ json: () => Promise.resolve({ success: true }) }))
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useInvalidateRefdata.mockReturnValue(mockInvalidate);
+  });
+
+  describe('initialization', () => {
+    test('constructs the correct queryKey using the ID', () => {
+      renderHook(() => useMutateRefdataValue({ endpoint: mockEndpoint, id: mockId }));
+      const sentConfig = useMutateGeneric.mock.calls[0][0];
+
+      expect(sentConfig.queryKey).toEqual([
+        'stripes-kint-components',
+        'useMutateRefdataValue',
+        mockId
+      ]);
+    });
+  });
+
+  describe('custom promiseReturns logic', () => {
+    let promiseReturns;
+    beforeEach(() => {
+      renderHook(() => useMutateRefdataValue({ endpoint: mockEndpoint, id: mockId }));
+      promiseReturns = useMutateGeneric.mock.calls[0][0].promiseReturns;
+    });
+
+    test('delete: sends a PUT to the parent category with _delete: true', async () => {
+      await promiseReturns.delete('value-abc', mockKy);
+      expect(mockKy.put).toHaveBeenCalledWith(
+        `${mockEndpoint}/${mockId}`,
+        {
+          json: {
+            id: mockId,
+            values: [{ id: 'value-abc', _delete: true }]
+          }
+        }
+      );
+    });
+
+    test('post: sends a PUT to the parent category with the new value data', async () => {
+      const newData = { label: 'New Value' };
+      await promiseReturns.post(newData, mockKy);
+      expect(mockKy.put).toHaveBeenCalledWith(
+        `${mockEndpoint}/${mockId}`,
+        {
+          json: {
+            id: mockId,
+            values: [newData]
+          }
+        }
+      );
+    });
+
+    test('put: sends a PUT to the parent category with the updated value data', async () => {
+      const updateData = { id: 'val-1', label: 'Updated' };
+      await promiseReturns.put(updateData, mockKy);
+      expect(mockKy.put).toHaveBeenCalledWith(
+        `${mockEndpoint}/${mockId}`,
+        {
+          json: {
+            id: mockId,
+            values: [updateData]
+          }
+        }
+      );
+    });
+  });
+
+  describe('afterQueryCalls lifecycle', () => {
+    test.each(['delete', 'post', 'put'])('Verb: %s triggers invalidation', async (verb) => {
+      renderHook(() => useMutateRefdataValue({ endpoint: mockEndpoint, id: mockId }));
+      const { afterQueryCalls } = useMutateGeneric.mock.calls[0][0];
+
+      await afterQueryCalls[verb]({ success: true });
+      expect(mockInvalidate).toHaveBeenCalled();
+    });
+  });
+});

package/src/lib/hooks/useMutateTemplates/useMutateTemplates.test.js

@@ -0,0 +1,33 @@
+import { renderHook } from '@folio/jest-config-stripes/testing-library/react';
+import useMutateGeneric from '../useMutateGeneric';
+import useInvalidateRefdata from '../useInvalidateRefdata';
+import useMutateTemplates from './useMutateTemplates';
+
+jest.mock('../useMutateGeneric');
+jest.mock('../useInvalidateRefdata');
+
+describe('useMutateTemplates', () => {
+  const mockEndpoint = 'erm/templates';
+  const mockInvalidate = jest.fn(() => Promise.resolve());
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useInvalidateRefdata.mockReturnValue(mockInvalidate);
+  });
+
+  test('passes the correct queryKey', () => {
+    renderHook(() => useMutateTemplates({ endpoint: mockEndpoint }));
+    const sentConfig = useMutateGeneric.mock.calls[0][0];
+    expect(sentConfig.queryKey).toEqual(['stripes-kint-components', 'useMutateTemplates']);
+  });
+
+  describe('afterQueryCalls', () => {
+    test.each(['delete', 'post', 'put'])('Verb: %s calls invalidateRefdata', async (verb) => {
+      renderHook(() => useMutateTemplates({ endpoint: mockEndpoint }));
+      const { afterQueryCalls } = useMutateGeneric.mock.calls[0][0];
+
+      await afterQueryCalls[verb]({});
+      expect(mockInvalidate).toHaveBeenCalled();
+    });
+  });
+});