mirror of https://github.com/jkjoy/sunpeiwen.git
312 lines
10 KiB
TypeScript
312 lines
10 KiB
TypeScript
import moize from '../src';
|
|
|
|
type Type = {
|
|
number: number;
|
|
};
|
|
|
|
const method = (one: number, two: Type) => one + two.number;
|
|
const promiseMethodResolves = (one: number, two: Type) =>
|
|
new Promise((resolve) => setTimeout(() => resolve(one + two.number), 1000));
|
|
const promiseMethodRejects =
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
(one: number, two: Type) =>
|
|
new Promise((resolve, reject) =>
|
|
setTimeout(() => reject(new Error('boom')), 1000)
|
|
);
|
|
|
|
describe('moize.updateCacheForKey', () => {
|
|
describe('success', () => {
|
|
it('will refresh the cache', () => {
|
|
const moized = moize.maxSize(2)(method, {
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
const result = moized(6, mutated);
|
|
|
|
expect(result).toBe(11);
|
|
|
|
mutated.number = 11;
|
|
|
|
const mutatedResult = moized(6, mutated);
|
|
|
|
// Result was not recalculated because `updateCacheForKey` returned `false` and the values are
|
|
// seen as unchanged.
|
|
expect(mutatedResult).toBe(result);
|
|
|
|
mutated.number = 10;
|
|
|
|
const refreshedResult = moized(6, mutated);
|
|
|
|
// Result was recalculated because `updateCacheForKey` returned `true`.
|
|
expect(refreshedResult).not.toBe(result);
|
|
expect(refreshedResult).toBe(16);
|
|
|
|
const { keys, values } = moized.cacheSnapshot;
|
|
|
|
expect(keys).toEqual([[6, mutated]]);
|
|
expect(values).toEqual([16]);
|
|
});
|
|
|
|
it('will refresh the cache based on external values', async () => {
|
|
const mockMethod = jest.fn(method);
|
|
|
|
let lastUpdate = Date.now();
|
|
|
|
const moized = moize.maxSize(2)(mockMethod, {
|
|
updateCacheForKey() {
|
|
const now = Date.now();
|
|
const last = lastUpdate;
|
|
|
|
lastUpdate = now;
|
|
|
|
return last + 1000 < now;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
moized(6, mutated);
|
|
moized(6, mutated);
|
|
moized(6, mutated);
|
|
|
|
expect(mockMethod).toHaveBeenCalledTimes(1);
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 2000));
|
|
|
|
moized(6, mutated);
|
|
|
|
expect(mockMethod).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('will refresh the cache when used with promises', async () => {
|
|
const moized = moize.maxSize(2)(promiseMethodResolves, {
|
|
isPromise: true,
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
const result = await moized(6, mutated);
|
|
|
|
expect(result).toBe(11);
|
|
|
|
mutated.number = 11;
|
|
|
|
const mutatedResult = await moized(6, mutated);
|
|
|
|
// Result was not recalculated because `updateCacheForKey` returned `false` and the values are
|
|
// seen as unchanged.
|
|
expect(mutatedResult).toBe(result);
|
|
|
|
mutated.number = 10;
|
|
|
|
const refreshedResult = await moized(6, mutated);
|
|
|
|
// Result was recalculated because `updateCacheForKey` returned `true`.
|
|
expect(refreshedResult).not.toBe(result);
|
|
expect(refreshedResult).toBe(16);
|
|
|
|
const { keys, values } = moized.cacheSnapshot;
|
|
|
|
expect(keys).toEqual([[6, mutated]]);
|
|
expect(values).toEqual([Promise.resolve(16)]);
|
|
});
|
|
|
|
it('will refresh the cache when used with custom key transformers', () => {
|
|
type ConditionalIncrement = {
|
|
force?: boolean;
|
|
};
|
|
|
|
let count = 0;
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const increment = (_?: ConditionalIncrement) => ++count;
|
|
|
|
const moized = moize.maxSize(2)(increment, {
|
|
isSerialized: true,
|
|
updateCacheForKey: (args: [ConditionalIncrement]) =>
|
|
args[0] && args[0].force === true,
|
|
serializer: () => ['always same'],
|
|
});
|
|
|
|
expect(moized()).toBe(1);
|
|
expect(moized()).toBe(1);
|
|
expect(moized({ force: true })).toBe(2);
|
|
expect(moized()).toBe(2);
|
|
});
|
|
|
|
it('will refresh the cache with shorthand', () => {
|
|
const moized = moize.updateCacheForKey(
|
|
(args) => args[1].number % 2 === 0
|
|
)(method);
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
const result = moized(6, mutated);
|
|
|
|
expect(result).toBe(11);
|
|
|
|
mutated.number = 11;
|
|
|
|
const mutatedResult = moized(6, mutated);
|
|
|
|
// Result was not recalculated because `updateCacheForKey` returned `false` and the values are
|
|
// seen as unchanged.
|
|
expect(mutatedResult).toBe(result);
|
|
|
|
mutated.number = 10;
|
|
|
|
const refreshedResult = moized(6, mutated);
|
|
|
|
// Result was recalculated because `updateCacheForKey` returned `true`.
|
|
expect(refreshedResult).not.toBe(result);
|
|
expect(refreshedResult).toBe(16);
|
|
|
|
const { keys, values } = moized.cacheSnapshot;
|
|
|
|
expect(keys).toEqual([[6, mutated]]);
|
|
expect(values).toEqual([16]);
|
|
});
|
|
|
|
it('will refresh the cache with composed shorthand', () => {
|
|
const moizer = moize.compose(
|
|
moize.maxSize(2),
|
|
moize.updateCacheForKey((args) => args[1].number % 2 === 0)
|
|
);
|
|
const moized = moizer(method);
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
const result = moized(6, mutated);
|
|
|
|
expect(result).toBe(11);
|
|
|
|
mutated.number = 11;
|
|
|
|
const mutatedResult = moized(6, mutated);
|
|
|
|
// Result was not recalculated because `updateCacheForKey` returned `false` and the values are
|
|
// seen as unchanged.
|
|
expect(mutatedResult).toBe(result);
|
|
|
|
mutated.number = 10;
|
|
|
|
const refreshedResult = moized(6, mutated);
|
|
|
|
// Result was recalculated because `updateCacheForKey` returned `true`.
|
|
expect(refreshedResult).not.toBe(result);
|
|
expect(refreshedResult).toBe(16);
|
|
|
|
const { keys, values } = moized.cacheSnapshot;
|
|
|
|
expect(keys).toEqual([[6, mutated]]);
|
|
expect(values).toEqual([16]);
|
|
});
|
|
});
|
|
|
|
describe('fail', () => {
|
|
it('surfaces the error if the function fails', () => {
|
|
const moized = moize.maxSize(2)(
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
(_1: number, _2: Type) => {
|
|
throw new Error('boom');
|
|
},
|
|
{
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
}
|
|
);
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
expect(() => moized(6, mutated)).toThrow(new Error('boom'));
|
|
});
|
|
|
|
it('surfaces the error if the promise rejects', async () => {
|
|
const moized = moize.maxSize(2)(promiseMethodRejects, {
|
|
isPromise: true,
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
await expect(moized(6, mutated)).rejects.toEqual(new Error('boom'));
|
|
});
|
|
|
|
it('should have nothing in cache if promise is rejected and key was never present', async () => {
|
|
const moized = moize.maxSize(2)(promiseMethodRejects, {
|
|
isPromise: true,
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
await expect(moized(6, mutated)).rejects.toEqual(new Error('boom'));
|
|
|
|
expect(moized.keys()).toEqual([]);
|
|
expect(moized.values()).toEqual([]);
|
|
});
|
|
|
|
// For some reason, this is causing `jest` to crash instead of handle the rejection
|
|
it.skip('should have nothing in cache if promise is rejected and key was present', async () => {
|
|
const moized = moize.maxSize(2)(promiseMethodRejects, {
|
|
isPromise: true,
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
|
|
const mutated = { number: 5 };
|
|
|
|
moized.set([6, mutated], Promise.resolve(11));
|
|
|
|
expect(moized.get([6, mutated])).toEqual(Promise.resolve(11));
|
|
|
|
mutated.number = 10;
|
|
|
|
await expect(moized(6, mutated)).rejects.toEqual(new Error('boom'));
|
|
|
|
expect(moized.keys()).toEqual([]);
|
|
expect(moized.values()).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('infrastructure', () => {
|
|
it('should have all the static properties of a standard moized method', () => {
|
|
const moized = moize.maxSize(2)(promiseMethodResolves, {
|
|
updateCacheForKey(args) {
|
|
return args[1].number % 2 === 0;
|
|
},
|
|
});
|
|
const standardMoized = moize.maxSize(2)(promiseMethodResolves);
|
|
|
|
expect(Object.getOwnPropertyNames(moized)).toEqual(
|
|
Object.getOwnPropertyNames(standardMoized)
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('edge cases', () => {
|
|
it('should retain the original function name', () => {
|
|
function myNamedFunction() {}
|
|
|
|
const memoized = moize(myNamedFunction, {
|
|
updateCacheForKey: () => false,
|
|
});
|
|
|
|
expect(memoized.name).toBe('moized(myNamedFunction)');
|
|
});
|
|
});
|
|
});
|