@mic-rexjs/usecases-react 1.5.1 → 1.6.1

package/es/hooks/useUseCase/index.test.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { objectUseCase, entityUseCase, } from '@mic-rexjs/usecases';
-import { describe, expect, jest, test } from '@jest/globals';
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
 import { renderHook, act, render, fireEvent, screen } from '@testing-library/react';
 import { useUseCase } from '.';
-import { useDeepCompareEffect, useMemoizedFn, useUpdate, useUpdateEffect } from 'ahooks';
+import { useDeepCompareEffect, useMemoizedFn, useMount, useUpdate, useUpdateEffect } from 'ahooks';
 import { Fragment, useEffect, useRef, useState } from 'react';
 const EXT_1 = '.png';
 const EXT_2 = '.jpg';
@@ -48,15 +48,15 @@ const fileUseCase = (options = {}) => {
     };
     return { ...entityReducers, init, setPath, readFile, isImage };
 };
+const subtractionReducer = jest.fn((value1, value2) => {
+    return value1 - value2;
+});
 const mathUseCase = (options = {}) => {
     const { extraValue = 0 } = options;
     const add = (value1, value2) => {
         return value1 + value2 + extraValue;
     };
-    const subtraction = (value1, value2) => {
-        return value1 - value2;
-    };
-    return { add, subtraction };
+    return { add, subtraction: subtractionReducer };
 };
 const fieldPathUseCase = () => {
     return objectUseCase();
@@ -118,6 +118,9 @@ const useDeepCompareUpdate = (callback, deps) => {
         callback();
     }, deps);
 };
+beforeEach(() => {
+    subtractionReducer.mockClear();
+});
 describe('useUseCase', () => {
     describe('`useUseCase` should work with 2+ arguments on provider mode', () => {
         test('check `context.length`', () => {
@@ -256,6 +259,107 @@ describe('useUseCase', () => {
             expect(result.current[1].init).not.toBe(init);
             expect(onUpdate).toHaveBeenCalledTimes(1);
         });
+        test('reducer call should be cached if component is at rendering phase', () => {
+            const buttonText = 'button';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const CacheTestComponent = () => {
+                const [, { add }] = useUseCase('', stringUseCase);
+                const update = useUpdate();
+                const onClick = () => {
+                    update();
+                };
+                add('x');
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+            expect(addReducer).toHaveBeenCalledWith('', 'x');
+            expect(addReducer).toHaveReturnedWith('x');
+            fireEvent.click(screen.getByText(buttonText));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+        });
+        test('reducer call should not be cached if component is not at rendering phase', () => {
+            const buttonText = 'button';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const CacheTestComponent = () => {
+                const [, { add }] = useUseCase('', stringUseCase);
+                const onClick = () => {
+                    add('x');
+                };
+                useMount(() => {
+                    add('x');
+                    add('x');
+                });
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(addReducer).toHaveBeenCalledTimes(2);
+            expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
+            expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
+            fireEvent.click(screen.getByText(buttonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+            expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+        });
+        test('reducer call should not be cached if entity or parameters have changed', () => {
+            let count = 0;
+            let addedText = 'x';
+            const setButtonText = 'button';
+            const updateButtonText = 'update';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const CacheTestComponent = () => {
+                const [, { add, setEntity }] = useUseCase('', stringUseCase);
+                const update = useUpdate();
+                add(addedText);
+                const onSet = () => {
+                    setEntity(`${count++}`);
+                };
+                const onUpdate = () => {
+                    update();
+                };
+                return (_jsxs("div", { children: [_jsx("button", { onClick: onSet, children: setButtonText }), _jsx("button", { onClick: onUpdate, children: updateButtonText })] }));
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+            expect(addReducer).toHaveBeenCalledWith('', 'x');
+            fireEvent.click(screen.getByText(setButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(2);
+            expect(addReducer).toHaveBeenCalledWith('0', 'x');
+            expect(addReducer).toHaveReturnedWith('0x');
+            addedText = 'y';
+            fireEvent.click(screen.getByText(updateButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+            expect(addReducer).toHaveBeenCalledWith('0', 'y');
+            expect(addReducer).toHaveReturnedWith('0y');
+            fireEvent.click(screen.getByText(updateButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+        });
         test('`options.stateless` should not generate new reducers when `yeild entity`', () => {
             const onUpdate = jest.fn();
             const { result, rerender } = renderHook((file = defaultFile) => {
@@ -455,198 +559,6 @@ describe('useUseCase', () => {
             expect(onUpdate).toHaveBeenCalledTimes(0);
             expect(onDeepUpdate).toHaveBeenCalledTimes(0);
         });
-    });
-    describe('`useUseCase` should work with 1+ arguments on non-entity mode', () => {
-        test('`entity` should equal `defaultFile`', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            expect(Array.isArray(reducers)).toBe(false);
-        });
-        test('returned reducer should work', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase);
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(3);
-        });
-        test('`options.extraValue` should be added after call `add` method', () => {
-            const { result } = renderHook(() => {
-                return useUseCase(mathUseCase, { extraValue: 5 });
-            });
-            const { current: reducers } = result;
-            const { add } = reducers;
-            expect(add(1, 2)).toBe(8);
-        });
-        test('when `options` has changed, it should not trigger update', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue });
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('when `deps` change, it should update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(1);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
-        });
-        test('empty `deps` should not update reducers', () => {
-            const onUpdate = jest.fn();
-            const onDeepUpdate = jest.fn();
-            const { result } = renderHook(() => {
-                const [extraValue, setExtraValue] = useState(0);
-                const reducers = useUseCase(mathUseCase, { extraValue }, []);
-                useUpdateEffect(() => {
-                    onUpdate();
-                }, [reducers]);
-                useDeepCompareUpdate(() => {
-                    onDeepUpdate();
-                }, [reducers]);
-                return setExtraValue;
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-            act(() => {
-                result.current(3);
-            });
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
-        });
-        test('should not trigger update', () => {
-            const onUpdate = jest.fn();
-            render(_jsx(MathParent, { onUpdate: onUpdate }));
-            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
-            expect(onUpdate).toHaveBeenCalledTimes(0);
-        });
-    });
-    describe('`useUseCase` should work with 1+ arguments on context mode', () => {
-        test('should work within <Child /> which it is under <Parent />', () => {
-            const textPrefix = '>>';
-            const onUpdate = jest.fn();
-            const onPathChange = jest.fn();
-            const onUndefinedEntity = jest.fn();
-            const onSetPath = jest.fn(() => {
-                return PATH_1;
-            });
-            render(_jsx("div", { children: _jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
-            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
-            expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate).toHaveBeenCalledTimes(1);
-            expect(onPathChange).toHaveBeenCalledWith(PATH_1);
-            fireEvent.click(screen.getByText(textPrefix + CHILD_BUTTON_TEXT));
-            expect(onSetPath).toHaveBeenCalledTimes(1);
-            expect(onUpdate).toHaveBeenCalledTimes(2);
-            expect(onPathChange).toHaveBeenCalledWith('');
-            expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
-        });
-        test('`options.onChange` event should be trigger at child elements', () => {
-            const onFirstChange = jest.fn();
-            const onSecondChange = jest.fn();
-            const onParentPathChange = jest.fn();
-            const firstButtonText = 'first button';
-            const secondButtonText = 'second button';
-            let onChange = onFirstChange;
-            const A = () => {
-                useUseCase(fileUseCase, { onChange });
-                return _jsx(Fragment, {});
-            };
-            const B = () => {
-                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
-                    onChange: onParentPathChange,
-                });
-                const onFirstClick = () => {
-                    setPath(PATH_1);
-                    onChange = onSecondChange;
-                };
-                const onSecondClick = () => {
-                    setPath('');
-                };
-                return (_jsxs(Provider, { children: [_jsx(A, {}), _jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
-            };
-            render(_jsx(B, {}));
-            expect(onFirstChange).toHaveBeenCalledTimes(0);
-            fireEvent.click(screen.getByText(firstButtonText));
-            expect(onFirstChange).toHaveBeenCalledTimes(1);
-            expect(onFirstChange).toHaveBeenLastCalledWith({ ...defaultFile, ext: EXT_1, path: PATH_1 }, defaultFile);
-            expect(onParentPathChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenCalledTimes(0);
-            fireEvent.click(screen.getByText(secondButtonText));
-            expect(onSecondChange).toHaveBeenCalledTimes(1);
-            expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, {
-                ...defaultFile,
-                ext: EXT_1,
-                path: PATH_1,
-            });
-            expect(onFirstChange).toHaveBeenCalledTimes(1);
-            expect(onParentPathChange).toHaveBeenCalledTimes(2);
-        });
-        test('`options.onChange` event should be trigger in orders', () => {
-            let changeTimes = 0;
-            const updateChangeTimes = () => {
-                return ++changeTimes;
-            };
-            const onChangeA = jest.fn(updateChangeTimes);
-            const onChangeB = jest.fn(updateChangeTimes);
-            const onChangeC = jest.fn(updateChangeTimes);
-            const buttonText = 'my button';
-            const A = ({ children }) => {
-                useUseCase(fileUseCase, { onChange: onChangeA });
-                return _jsx(Fragment, { children: children });
-            };
-            const B = () => {
-                useUseCase(fileUseCase, { onChange: onChangeB });
-                return _jsx(Fragment, {});
-            };
-            const C = () => {
-                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
-                    onChange: onChangeC,
-                });
-                const onFirstClick = () => {
-                    setPath(PATH_1);
-                };
-                return (_jsxs(Provider, { children: [_jsx(A, { children: _jsx(B, {}) }), _jsx("button", { onClick: onFirstClick, children: buttonText })] }));
-            };
-            render(_jsx(C, {}));
-            expect(changeTimes).toBe(0);
-            fireEvent.click(screen.getByText(buttonText));
-            expect(onChangeA).toHaveReturnedWith(2);
-            expect(onChangeB).toHaveReturnedWith(1);
-            expect(onChangeC).toHaveReturnedWith(3);
-        });
         test('`options.watch` should be trigger at child elements', () => {
             const onFirstExtChange = jest.fn();
             const onSecondExtChange = jest.fn();
@@ -1149,4 +1061,373 @@ describe('useUseCase', () => {
             });
         });
     });
+    describe('`useUseCase` should work with 1+ arguments on non-entity mode', () => {
+        test('`entity` should equal `defaultFile`', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase);
+            });
+            const { current: reducers } = result;
+            expect(Array.isArray(reducers)).toBe(false);
+        });
+        test('returned reducer should work', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase);
+            });
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(3);
+        });
+        test('reducer call should not be cached if component is at rendering phase', () => {
+            const buttonText = 'button';
+            const CacheTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const update = useUpdate();
+                const onClick = () => {
+                    update();
+                };
+                subtraction(5, 3);
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(1);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 3);
+            expect(subtractionReducer).toHaveReturnedWith(2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(3);
+        });
+        test('reducer call should not be cached if component is not at rendering phase', () => {
+            const buttonText = 'button';
+            const CacheTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const onClick = () => {
+                    subtraction(5, 3);
+                };
+                useMount(() => {
+                    subtraction(5, 3);
+                    subtraction(5, 3);
+                });
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            render(_jsx(CacheTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(1, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(1, 2);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(2, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(2, 2);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(3);
+            expect(subtractionReducer).toHaveBeenNthCalledWith(3, 5, 3);
+            expect(subtractionReducer).toHaveNthReturnedWith(3, 2);
+        });
+        test('reducer call should not be cached if parameters have changed', () => {
+            let count = 0;
+            const buttonText = 'button';
+            const StringUseCaseTestComponent = () => {
+                const { subtraction } = useUseCase(mathUseCase);
+                const update = useUpdate();
+                subtraction(5, count++);
+                const onUpdate = () => {
+                    update();
+                };
+                return (_jsx("div", { children: _jsx("button", { onClick: onUpdate, children: buttonText }) }));
+            };
+            render(_jsx(StringUseCaseTestComponent, {}));
+            expect(subtractionReducer).toHaveBeenCalledTimes(1);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 0);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(subtractionReducer).toHaveBeenCalledTimes(2);
+            expect(subtractionReducer).toHaveBeenCalledWith(5, 1);
+            expect(subtractionReducer).toHaveReturnedWith(4);
+        });
+        test('`options.extraValue` should be added after call `add` method', () => {
+            const { result } = renderHook(() => {
+                return useUseCase(mathUseCase, { extraValue: 5 });
+            });
+            const { current: reducers } = result;
+            const { add } = reducers;
+            expect(add(1, 2)).toBe(8);
+        });
+        test('when `options` has changed, it should not trigger update', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue });
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('when `deps` change, it should update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, [extraValue]);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(1);
+        });
+        test('empty `deps` should not update reducers', () => {
+            const onUpdate = jest.fn();
+            const onDeepUpdate = jest.fn();
+            const { result } = renderHook(() => {
+                const [extraValue, setExtraValue] = useState(0);
+                const reducers = useUseCase(mathUseCase, { extraValue }, []);
+                useUpdateEffect(() => {
+                    onUpdate();
+                }, [reducers]);
+                useDeepCompareUpdate(() => {
+                    onDeepUpdate();
+                }, [reducers]);
+                return setExtraValue;
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+            act(() => {
+                result.current(3);
+            });
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+            expect(onDeepUpdate).toHaveBeenCalledTimes(0);
+        });
+        test('should not trigger update', () => {
+            const onUpdate = jest.fn();
+            render(_jsx(MathParent, { onUpdate: onUpdate }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onUpdate).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('`useUseCase` should work with 1+ arguments on context mode', () => {
+        test('should work within <Child /> which it is under <Parent />', () => {
+            const textPrefix = '>>';
+            const onUpdate = jest.fn();
+            const onPathChange = jest.fn();
+            const onUndefinedEntity = jest.fn();
+            const onSetPath = jest.fn(() => {
+                return PATH_1;
+            });
+            render(_jsx("div", { children: _jsx(Parent, { onSetPath: onSetPath, children: _jsx(Child, { textPrefix: textPrefix, onUpdate: onUpdate, onPathChange: onPathChange, onUndefinedEntity: onUndefinedEntity }) }) }));
+            fireEvent.click(screen.getByText(PARENT_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onUpdate).toHaveBeenCalledTimes(1);
+            expect(onPathChange).toHaveBeenCalledWith(PATH_1);
+            fireEvent.click(screen.getByText(textPrefix + CHILD_BUTTON_TEXT));
+            expect(onSetPath).toHaveBeenCalledTimes(1);
+            expect(onUpdate).toHaveBeenCalledTimes(2);
+            expect(onPathChange).toHaveBeenCalledWith('');
+            expect(onUndefinedEntity).toHaveBeenCalledTimes(0);
+        });
+        test('reducer call should be cached if component is at rendering phase in child components', () => {
+            const buttonText = 'button';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const A = () => {
+                const [, { add }] = useUseCase(stringUseCase);
+                const update = useUpdate();
+                const onClick = () => {
+                    update();
+                };
+                add('x');
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            const B = () => {
+                const [, , Provider] = useUseCase('', stringUseCase);
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+            expect(addReducer).toHaveBeenCalledWith('', 'x');
+            expect(addReducer).toHaveReturnedWith('x');
+            fireEvent.click(screen.getByText(buttonText));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+        });
+        test('reducer call should not be cached if component is not at rendering phase in child components', () => {
+            const buttonText = 'button';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const A = () => {
+                const [, { add }] = useUseCase(stringUseCase);
+                const onClick = () => {
+                    add('x');
+                };
+                useMount(() => {
+                    add('x');
+                    add('x');
+                });
+                return _jsx("button", { onClick: onClick, children: buttonText });
+            };
+            const B = () => {
+                const [, , Provider] = useUseCase('', stringUseCase);
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(addReducer).toHaveBeenCalledTimes(2);
+            expect(addReducer).toHaveBeenNthCalledWith(1, '', 'x');
+            expect(addReducer).toHaveBeenNthCalledWith(2, '', 'x');
+            fireEvent.click(screen.getByText(buttonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+            expect(addReducer).toHaveBeenNthCalledWith(3, '', 'x');
+        });
+        test('reducer call should not be cached if entity or parameters have changed in child components', () => {
+            let count = 0;
+            let addedText = 'x';
+            const setButtonText = 'button';
+            const updateButtonText = 'update';
+            const addReducer = jest.fn((entity, substring) => {
+                return entity + substring;
+            });
+            const stringUseCase = () => {
+                const entityReducers = entityUseCase();
+                return {
+                    ...entityReducers,
+                    add: addReducer,
+                };
+            };
+            const A = () => {
+                const [, { add, setEntity }] = useUseCase(stringUseCase);
+                const update = useUpdate();
+                add(addedText);
+                const onSet = () => {
+                    setEntity(`${count++}`);
+                };
+                const onUpdate = () => {
+                    update();
+                };
+                return (_jsxs("div", { children: [_jsx("button", { onClick: onSet, children: setButtonText }), _jsx("button", { onClick: onUpdate, children: updateButtonText })] }));
+            };
+            const B = () => {
+                const [, , Provider] = useUseCase('', stringUseCase);
+                return (_jsx(Provider, { children: _jsx(A, {}) }));
+            };
+            render(_jsx(B, {}));
+            expect(addReducer).toHaveBeenCalledTimes(1);
+            expect(addReducer).toHaveBeenCalledWith('', 'x');
+            fireEvent.click(screen.getByText(setButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(2);
+            expect(addReducer).toHaveBeenCalledWith('0', 'x');
+            expect(addReducer).toHaveReturnedWith('0x');
+            addedText = 'y';
+            fireEvent.click(screen.getByText(updateButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+            expect(addReducer).toHaveBeenCalledWith('0', 'y');
+            expect(addReducer).toHaveReturnedWith('0y');
+            fireEvent.click(screen.getByText(updateButtonText));
+            expect(addReducer).toHaveBeenCalledTimes(3);
+        });
+        test('`options.onChange` event should be trigger at child elements', () => {
+            const onFirstChange = jest.fn();
+            const onSecondChange = jest.fn();
+            const onParentPathChange = jest.fn();
+            const firstButtonText = 'first button';
+            const secondButtonText = 'second button';
+            let onChange = onFirstChange;
+            const A = () => {
+                useUseCase(fileUseCase, { onChange });
+                return _jsx(Fragment, {});
+            };
+            const B = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    onChange: onParentPathChange,
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                    onChange = onSecondChange;
+                };
+                const onSecondClick = () => {
+                    setPath('');
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, {}), _jsx("button", { onClick: onFirstClick, children: firstButtonText }), _jsx("button", { onClick: onSecondClick, children: secondButtonText })] }));
+            };
+            render(_jsx(B, {}));
+            expect(onFirstChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(firstButtonText));
+            expect(onFirstChange).toHaveBeenCalledTimes(1);
+            expect(onFirstChange).toHaveBeenLastCalledWith({ ...defaultFile, ext: EXT_1, path: PATH_1 }, defaultFile);
+            expect(onParentPathChange).toHaveBeenCalledTimes(1);
+            expect(onSecondChange).toHaveBeenCalledTimes(0);
+            fireEvent.click(screen.getByText(secondButtonText));
+            expect(onSecondChange).toHaveBeenCalledTimes(1);
+            expect(onSecondChange).toHaveBeenLastCalledWith(defaultFile, {
+                ...defaultFile,
+                ext: EXT_1,
+                path: PATH_1,
+            });
+            expect(onFirstChange).toHaveBeenCalledTimes(1);
+            expect(onParentPathChange).toHaveBeenCalledTimes(2);
+        });
+        test('`options.onChange` event should be trigger in orders', () => {
+            let changeTimes = 0;
+            const updateChangeTimes = () => {
+                return ++changeTimes;
+            };
+            const onChangeA = jest.fn(updateChangeTimes);
+            const onChangeB = jest.fn(updateChangeTimes);
+            const onChangeC = jest.fn(updateChangeTimes);
+            const buttonText = 'my button';
+            const A = ({ children }) => {
+                useUseCase(fileUseCase, { onChange: onChangeA });
+                return _jsx(Fragment, { children: children });
+            };
+            const B = () => {
+                useUseCase(fileUseCase, { onChange: onChangeB });
+                return _jsx(Fragment, {});
+            };
+            const C = () => {
+                const [, { setPath }, Provider] = useUseCase(defaultFile, fileUseCase, {
+                    onChange: onChangeC,
+                });
+                const onFirstClick = () => {
+                    setPath(PATH_1);
+                };
+                return (_jsxs(Provider, { children: [_jsx(A, { children: _jsx(B, {}) }), _jsx("button", { onClick: onFirstClick, children: buttonText })] }));
+            };
+            render(_jsx(C, {}));
+            expect(changeTimes).toBe(0);
+            fireEvent.click(screen.getByText(buttonText));
+            expect(onChangeA).toHaveReturnedWith(2);
+            expect(onChangeB).toHaveReturnedWith(1);
+            expect(onChangeC).toHaveReturnedWith(3);
+        });
+    });
 });