File size: 4,699 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
// NOTE: most behavior that useAsyncFn provides
// is covered be the useAsync tests.
//
// The main difference is that useAsyncFn
// does not automatically invoke the function
// and it can take arguments.
import { act, renderHook } from '@testing-library/react-hooks';
import useAsyncFn, { AsyncState } from '../src/useAsyncFn';
type AdderFn = (a?: number, b?: number) => Promise<number>;
describe('useAsyncFn', () => {
it('should be defined', () => {
expect(useAsyncFn).toBeDefined();
});
describe('the callback can be awaited and return the value', () => {
let hook;
const adder: AdderFn = async (a?: number, b?: number): Promise<number> => {
return (a || 0) + (b || 0);
};
beforeEach(() => {
// NOTE: renderHook isn't good at inferring array types
hook = renderHook<{ fn: AdderFn }, [AsyncState<number>, AdderFn]>(
({ fn }) => useAsyncFn(fn),
{
initialProps: { fn: adder },
}
);
});
it('awaits the result', async () => {
expect.assertions(3);
const [, callback] = hook.result.current;
let result;
await act(async () => {
result = await callback(5, 7);
});
expect(result).toEqual(12);
const [state] = hook.result.current;
expect(state.value).toEqual(12);
expect(result).toEqual(state.value);
});
});
describe('args can be passed to the function', () => {
let hook;
let callCount = 0;
const adder = async (a?: number, b?: number): Promise<number> => {
callCount++;
return (a || 0) + (b || 0);
};
beforeEach(() => {
// NOTE: renderHook isn't good at inferring array types
hook = renderHook<{ fn: AdderFn }, [AsyncState<number>, AdderFn]>(
({ fn }) => useAsyncFn(fn),
{
initialProps: {
fn: adder,
},
}
);
});
it('initially does not have a value', () => {
const [state] = hook.result.current;
expect(state.value).toEqual(undefined);
expect(state.loading).toEqual(false);
expect(state.error).toEqual(undefined);
expect(callCount).toEqual(0);
});
describe('when invoked', () => {
it('resolves a value derived from args', async () => {
expect.assertions(4);
const [, callback] = hook.result.current;
act(() => {
callback(2, 7);
});
hook.rerender({ fn: adder });
await hook.waitForNextUpdate();
const [state] = hook.result.current;
expect(callCount).toEqual(1);
expect(state.loading).toEqual(false);
expect(state.error).toEqual(undefined);
expect(state.value).toEqual(9);
});
});
});
it('should only consider last call and discard previous ones', async () => {
const queuedPromises: { id: number; resolve: () => void }[] = [];
const delayedFunction1 = () => {
return new Promise<number>((resolve) =>
queuedPromises.push({ id: 1, resolve: () => resolve(1) })
);
};
const delayedFunction2 = () => {
return new Promise<number>((resolve) =>
queuedPromises.push({ id: 2, resolve: () => resolve(2) })
);
};
const hook = renderHook<
{ fn: () => Promise<number> },
[AsyncState<number>, () => Promise<number>]
>(({ fn }) => useAsyncFn(fn, [fn]), {
initialProps: { fn: delayedFunction1 },
});
act(() => {
hook.result.current[1](); // invoke 1st callback
});
hook.rerender({ fn: delayedFunction2 });
act(() => {
hook.result.current[1](); // invoke 2nd callback
});
act(() => {
queuedPromises[1].resolve();
queuedPromises[0].resolve();
});
await hook.waitForNextUpdate();
expect(hook.result.current[0]).toEqual({ loading: false, value: 2 });
});
it('should keeping value of initialState when loading', async () => {
const fetch = async () => 'new state';
const initialState = { loading: false, value: 'init state' };
const hook = renderHook<
{ fn: () => Promise<string> },
[AsyncState<string>, () => Promise<string>]
>(({ fn }) => useAsyncFn(fn, [fn], initialState), {
initialProps: { fn: fetch },
});
const [state, callback] = hook.result.current;
expect(state.loading).toBe(false);
expect(state.value).toBe('init state');
act(() => {
callback();
});
expect(hook.result.current[0].loading).toBe(true);
expect(hook.result.current[0].value).toBe('init state');
await hook.waitForNextUpdate();
expect(hook.result.current[0].loading).toBe(false);
expect(hook.result.current[0].value).toBe('new state');
});
});
|