cachette 3.0.1 → 4.0.2

package/test/CacheInstance_test.ts

@@ -0,0 +1,488 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { LocalCache } from '../src/lib/LocalCache';
+import { RedisCache } from '../src/lib/RedisCache';
+import { WriteThroughCache } from '../src/lib/WriteThroughCache';
+import { CacheInstance, FetchingFunction } from '../src/lib/CacheInstance';
+
+async function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// set env var TEST_REDIS_URL (e.g. redis://localhost:6379) to enable running
+// the tests with Redis
+
+describe('CacheInstance', () => {
+
+  runTests('local', new LocalCache());
+
+  if (process.env.TEST_REDIS_URL) {
+    const redisCache = new RedisCache(process.env.TEST_REDIS_URL);
+    runTests('redis', redisCache);
+
+    const writeThroughCache = new WriteThroughCache(process.env.TEST_REDIS_URL);
+    runTests('writeThrough', writeThroughCache);
+  }
+
+});
+
+function runTests(name: string, cache: CacheInstance): void {
+
+  const lockSupported = cache.isLockingSupported();
+  const ifLockIt = (cache && cache.isLockingSupported()) ? it : it.skip;
+  let lockSpy: sinon.SinonSpy;
+  let unlockSpy: sinon.SinonSpy;
+
+  before(() => {
+    if (lockSupported) {
+      lockSpy = sinon.spy(cache, 'lock');
+      unlockSpy = sinon.spy(cache, 'unlock');
+    }
+  });
+
+  beforeEach(() => {
+    if (lockSupported) {
+      lockSpy.resetHistory();
+      unlockSpy.resetHistory();
+    }
+  });
+
+  after(() => {
+    if (lockSpy) {
+      lockSpy.restore();
+    }
+    if (unlockSpy) {
+      unlockSpy.restore();
+    }
+  });
+
+
+  describe(`getOrFetchValue - ${name}`, () => {
+
+    beforeEach(() => cache.clear());
+
+    it('does not fetch if value in cache', async () => {
+      const key = `key${Math.random()}`;
+      let numCalled = 0;
+      const object = {
+        fetch: async (v) => {
+          numCalled++;
+          return v;
+        },
+      };
+
+      await cache.setValue(key, 'value');
+      const fetchFunction: () => Promise<string> = object.fetch.bind(object, 'newvalue');
+      const value = await cache.getOrFetchValue(key, 10, fetchFunction);
+      expect(value).to.eql('value');
+      expect(numCalled).to.eql(0);
+      if (lockSupported) {
+        sinon.assert.notCalled(lockSpy);
+        sinon.assert.notCalled(unlockSpy);
+      }
+    });
+
+    it('fetches if value not in cache', async () => {
+      let numCalled = 0;
+      const object = {
+        fetch: async (v) => {
+          numCalled++;
+          return v;
+        },
+      };
+
+      await cache.setValue('key2', 'value');
+      const fetchFunction = object.fetch.bind(object, 'newvalue');
+      const value = await cache.getOrFetchValue(
+        'key',
+        10,
+        fetchFunction,
+      );
+      expect(value).to.eql('newvalue');
+      expect(numCalled).to.eql(1);
+      if (lockSupported) {
+        sinon.assert.notCalled(lockSpy);
+        sinon.assert.notCalled(unlockSpy);
+      }
+    });
+
+    it('does not cache exceptions by default', async () => {
+      let numCalled = 0;
+      const object = {
+        fetchThatThrows: async () => {
+          numCalled++;
+          throw new Error(`nope ${numCalled}`);
+        },
+      };
+
+      const fetchFunction = object.fetchThatThrows.bind(object, 'newvalue');
+      try {
+        await cache.getOrFetchValue('key', 10, fetchFunction);
+      } catch (err) {
+        expect(err.message).to.equal('nope 1');
+      }
+      expect(numCalled).to.equal(1);
+
+      try {
+        await cache.getOrFetchValue('key', 10, fetchFunction);
+      } catch (err) {
+        expect(err.message).to.equal('nope 2'); // <- no caching happened
+      }
+      expect(numCalled).to.equal(2);
+    });
+
+    it('caches exceptions if asked to', async () => {
+      let numCalled = 0;
+      const object = {
+        fetchThatThrows: async () => {
+          numCalled++;
+          const error = new Error(`nope ${numCalled}`);
+          error.name = 'MyCustomError';
+          // Some people enrich their errors objects with metadata.
+          // We ensure to preserve these.
+          error['myStringProperty'] = 'foo';
+          error['myBooleanProperty'] = true;
+          error['myNumberProperty'] = 1789.1789;
+          throw error;
+        },
+      };
+      const fetchFunction = object.fetchThatThrows.bind(object, 'newvalue');
+
+      let didThrow = false;
+      const getFromCache = async () => cache.getOrFetchValue('key', 10, fetchFunction, undefined, () => true);
+      try {
+        await getFromCache();
+      } catch (err) {
+        // initial throw, without cache
+        didThrow = true;
+        expect(err.message).to.equal('nope 1');
+        expect(err.name).to.equal('MyCustomError');
+        expect(err.myStringProperty).to.equal('foo');
+        expect(err.myBooleanProperty).to.equal(true);
+        expect(err.myNumberProperty).to.equal(1789.1789);
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(1);
+
+      didThrow = false;
+      try {
+        await getFromCache();
+      } catch (err) {
+        // second throw, cached
+        didThrow = true;
+        expect(err.message).to.equal('nope 1'); // <-- from cache; didn't increase
+        expect(err.name).to.equal('MyCustomError');
+        expect(err.myStringProperty).to.equal('foo');
+        expect(err.myBooleanProperty).to.equal(true);
+        expect(err.myNumberProperty).to.equal(1789.1789);
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(1); // <-- from cache; didn't increase
+    });
+
+    it('honors the shouldCacheError callback to determine whether to cache or not to cache -- (?, that is the question)', async () => {
+      let numCalled = 0;
+      const object = {
+        fetchThatThrowsAfterThree: async () => {
+          numCalled++;
+          const error = new Error(`nope ${numCalled}`);
+          error.name = numCalled >= 3 ? 'CacheableError' : 'NonCacheableError';
+          throw error;
+        },
+      };
+      const fetchFunction = object.fetchThatThrowsAfterThree.bind(object, 'newvalue');
+
+      let didThrow = false;
+      const getFromCache = async () => cache.getOrFetchValue(
+        'key',
+        10,
+        fetchFunction,
+        undefined,
+        (err) => err.name !== 'NonCacheableError',
+      );
+      try {
+        await getFromCache();
+      } catch (err) {
+        didThrow = true;
+        expect(err.message).to.equal('nope 1');
+        expect(err.name).to.equal('NonCacheableError');
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(1);
+
+      didThrow = false;
+      try {
+        await getFromCache();
+      } catch (err) {
+        didThrow = true;
+        expect(err.message).to.equal('nope 2');
+        expect(err.name).to.equal('NonCacheableError');
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(2); // <-- from actuall call, did increase
+
+      // next calls (after third call) will produce a cacheable error
+      didThrow = false;
+      try {
+        await getFromCache();
+      } catch (err) {
+        didThrow = true;
+        expect(err.message).to.equal('nope 3');
+        expect(err.name).to.equal('CacheableError');
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(3); // <-- from actual call, did increase
+
+      didThrow = false;
+      try {
+        await getFromCache();
+      } catch (err) {
+        didThrow = true;
+        expect(err.message).to.equal('nope 3');
+        expect(err.name).to.equal('CacheableError');
+      }
+      expect(didThrow).to.be.true;
+      expect(numCalled).to.equal(3); // <-- from cache, didn't increase
+    });
+
+    it('fetches once if multiple simultaneous requests', async () => {
+      let numCalled = 0;
+      const object = {
+        fetch: async (value) => {
+          numCalled++;
+          return value;
+        },
+      };
+
+      await cache.setValue('key2', 'value');
+
+      const fetchFunction = object.fetch.bind(object, 'newvalue');
+      const callGetOrFetch = () => cache.getOrFetchValue(
+        'key',
+        10,
+        fetchFunction,
+      );
+
+      const calls: Promise<any>[] = [];
+      for (let i = 0; i < 100; i++) {
+        calls.push(callGetOrFetch());
+      }
+
+      const values = await Promise.all(calls);
+      expect(values.length).to.eql(100);
+      for (const value of values) {
+        expect(value).to.eql('newvalue');
+      }
+      expect(numCalled).to.eql(1);
+    });
+
+    it('fetches once each if multiple simultaneous of two requests', async () => {
+      let numCalled1 = 0;
+      let numCalled2 = 0;
+      const object = {
+        fetch1: async (value) => {
+          numCalled1++;
+          return value;
+        },
+        fetch2: async (value) => {
+          numCalled2++;
+          return `${value}bis`;
+        },
+      };
+
+      const callGetOrFetch = (key, fn) => {
+        const fetchFunction = fn.bind(object, 'newvalue');
+        return cache.getOrFetchValue(
+          key,
+          10,
+          fetchFunction,
+        );
+      };
+
+      const calls: Promise<any>[] = [];
+
+      for (let i = 0; i < 100; i++) {
+        const fn = (i % 2) ? object.fetch1 : object.fetch2;
+        const key = (i % 2) ? 'key1' : 'key2';
+        calls.push(callGetOrFetch(key, fn as FetchingFunction));
+      }
+
+      const values = await Promise.all(calls);
+      expect(values.length).to.eql(100);
+      let count1 = 0;
+      let count2 = 0;
+      for (const value of values) {
+        if (value === 'newvalue') {
+          count1++;
+        } else if (value === 'newvaluebis') {
+          count2++;
+        } else {
+          expect(value).to.eql('newvalue');
+        }
+      }
+      expect(numCalled1).to.eql(1);
+      expect(numCalled2).to.eql(1);
+      expect(count1).to.eql(50);
+      expect(count2).to.eql(50);
+    });
+
+    it('handles errors during simultaneous requests', async () => {
+      const object = {
+        fetch: async (): Promise<number> => {
+          throw new Error('basta');
+        },
+      };
+
+      const callGetOrFetch = () => cache.getOrFetchValue(
+        'key',
+        10,
+        object.fetch,
+      );
+
+      const calls: Promise<any>[] = [];
+      for (let i = 0; i < 10; i++) {
+        calls.push(callGetOrFetch());
+      }
+
+      let numExceptions = 0;
+      for (const call of calls) {
+        await call.catch(() => numExceptions++);
+      }
+
+      expect(numExceptions).to.eql(10);
+    });
+
+    ifLockIt('creates locks that expire', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      await cache.lock(`${prefix}_sublock1`, 50);
+      const locksExist = await cache.hasLock(prefix);
+      expect(locksExist).to.be.true;
+
+      await sleep(51);
+      const locksExistAfterSleeping = await cache.hasLock(prefix);
+      expect(locksExistAfterSleeping).to.be.false;
+    });
+
+    ifLockIt('waits for expiry of existing locks', async () => {
+      const key = `prefix_${Math.random()}`;
+      const timeBeforeFirstLock = Date.now();
+      const firstLockTTL = 50;
+      await cache.lock(key, firstLockTTL);
+      const locksExist = await cache.hasLock(key);
+      expect(locksExist).to.be.true;
+
+      await cache.lock(key, 1000);
+      const timeAfterFirstLock = Date.now();
+      const locksStillExist = await cache.hasLock(key);
+      expect(locksStillExist).to.be.true;
+
+      expect(timeAfterFirstLock - timeBeforeFirstLock).to.be.greaterThanOrEqual(firstLockTTL);
+    });
+
+    ifLockIt('finds no lock if pattern does not match', async () => {
+      await cache.lock(`lock__${Math.random()}`, 10000);
+      await cache.lock(`otherlock__${Math.random()}`, 10000);
+
+      const locksExist = await cache.hasLock('whatever');
+      expect(locksExist).to.be.false;
+    });
+
+    ifLockIt('finds locks if a lock matches pattern', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      await cache.lock(`${prefix}_sublock1`, 10000);
+
+      const locksExist = await cache.hasLock(prefix);
+      expect(locksExist).to.be.true;
+    });
+
+    ifLockIt('finds locks if a lock matches pattern, with already a star at the end', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      await cache.lock(`${prefix}_sublock1`, 10000);
+
+      const locksExist = await cache.hasLock(`${prefix}*`);
+      expect(locksExist).to.be.true;
+    });
+
+    ifLockIt('finds no lock if a lock matched pattern, but was unlocked', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      const lock = await cache.lock(`${prefix}_sublock1`, 10000);
+      await cache.unlock(lock);
+
+      const locksExist = await cache.hasLock(prefix);
+      expect(locksExist).to.be.false;
+    });
+
+    ifLockIt('finds locks if several locks match pattern', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      await cache.lock(`${prefix}_sublock1`, 10000);
+      await cache.lock(`${prefix}_sublock2`, 10000);
+
+      const locksExist = await cache.hasLock(prefix);
+      expect(locksExist).to.be.true;
+    });
+
+    ifLockIt('returns no locks only when all the matching locks are cleared', async () => {
+      const prefix = `prefix_${Math.random()}`;
+      const lock1 = await cache.lock(`${prefix}_sublock1`, 10000);
+      expect(await cache.hasLock(prefix)).to.be.true;
+
+      const lock2 = await cache.lock(`${prefix}_sublock2`, 10000);
+      expect(await cache.hasLock(prefix)).to.be.true;
+
+      await cache.unlock(lock1);
+      expect(await cache.hasLock(prefix)).to.be.true;
+
+      await cache.unlock(lock2);
+      expect(await cache.hasLock(prefix)).to.be.false;
+    });
+
+    ifLockIt('locks before fetching if value not in cache', async () => {
+      const key = `key${Math.random()}`;
+      let numCalled = 0;
+      const object = {
+        fetch: async (v) => {
+          numCalled++;
+          return v;
+        },
+      };
+
+      const fetchFunction = object.fetch.bind(object, 'newvalue');
+      const value = await cache.getOrFetchValue(key, 10, fetchFunction, 1);  // enable locking
+
+      expect(value).to.eql('newvalue');
+      expect(numCalled).to.eql(1);
+      sinon.assert.calledOnce(lockSpy);
+      sinon.assert.calledOnce(unlockSpy);
+    });
+
+    ifLockIt('does not fetch if value already in cache after lock', async () => {
+      const key = `key${Math.random()}`;
+      // steal the lock
+      const lock = await cache.lock(`lock__${key}`, 1000);
+
+      let numCalled = 0;
+      const object = {
+        fetch: async (v) => {
+          numCalled++;
+          return v;
+        },
+      };
+
+      const fetchFunction = object.fetch.bind(object, 'newvalue');
+
+      setTimeout(async () => {
+        await cache.setValue(key, 'abcd');
+        await cache.unlock(lock);
+      }, 40);
+      const value = await cache.getOrFetchValue(key, 10, fetchFunction, 1);
+
+      expect(value).to.eql('abcd');
+      expect(numCalled).to.eql(0);
+      sinon.assert.calledTwice(lockSpy);   // includes our own call above
+      sinon.assert.calledTwice(unlockSpy);
+    });
+
+  });
+
+}

package/test/LocalCache_test.ts

@@ -0,0 +1,128 @@
+import { expect } from 'chai';
+
+import { LocalCache } from '../src/lib/LocalCache';
+
+
+describe('LocalCache', () => {
+
+  it('can set values', async () => {
+    const cache = new LocalCache();
+    const wasSet = await cache.setValue('key', 'value');
+    expect(wasSet).to.be.true;
+    expect(await cache.itemCount()).to.equal(1);
+    const value = await cache.getValue('key');
+    expect(value).to.equal('value');
+    expect(await cache.itemCount()).to.equal(1);
+  });
+
+  it('can set/get numbers', async function (): Promise<void> {
+    const cache = new LocalCache();
+
+    await cache.setValue('numZero', 0);
+    expect(await cache.getValue('numZero')).to.equal(0);
+
+    await cache.setValue('numFloat', 123.456);
+    expect(await cache.getValue('numFloat')).to.equal(123.456);
+
+    await cache.setValue('numNegative', -99);
+    expect(await cache.getValue('numNegative')).to.equal(-99);
+
+    await cache.setValue('numMax', Number.MAX_SAFE_INTEGER);
+    expect(await cache.getValue('numMax')).to.equal(Number.MAX_SAFE_INTEGER);
+
+    await cache.setValue('numInfinity', Infinity);
+    expect(await cache.getValue('numInfinity')).to.equal(Infinity);
+
+    await cache.setValue('numBarf', 0.1 + 0.2); // 0.30000000000000004, IEEE754
+    expect(await cache.getValue('numBarf')).to.equal(0.1 + 0.2);
+  });
+
+  it('will not throw if we set a value of undefined', async () => {
+    const cache = new LocalCache();
+    expect(await cache.itemCount()).to.equal(0);
+    const wasSet = await cache.setValue('key', undefined);
+    expect(await cache.itemCount()).to.equal(0);
+    expect(wasSet).to.be.false;
+    const value = await cache.getValue('key');
+    expect(await cache.itemCount()).to.equal(0);
+    expect(value).not.to.exist;
+  });
+
+  it('can set values with expiry', async () => {
+    const cache = new LocalCache();
+    await cache.setValue('key', 'value', .2);
+    let value = await cache.getValue('key');
+    expect(value).to.equal('value');
+    await sleep(250);
+    value = await cache.getValue('key');
+    expect(value).to.equal(undefined);
+
+  });
+
+  it('can delete a value', async () => {
+    const cache = new LocalCache();
+    await cache.setValue('key', 'value');
+
+    expect(await cache.getValue('key')).to.equal('value');
+    await cache.delValue('key');
+
+    expect(await cache.getValue('key')).not.to.exist;
+
+  });
+
+  it('will not grow in size past the maximum size', async () => {
+    const origMax = LocalCache['DEFAULT_MAX_ITEMS'];
+    LocalCache['DEFAULT_MAX_ITEMS'] = 5;
+
+    const cache = new LocalCache();
+    await cache.setValue('1', '1');
+    await cache.setValue('2', '2');
+    await cache.setValue('3', '3');
+    await cache.setValue('4', '4');
+    await cache.setValue('5', '5');
+    await cache.setValue('6', '6');
+    await cache.setValue('7', '7');
+    await cache.setValue('8', '8');
+
+    const cacheSize = await cache.itemCount();
+    expect(cacheSize).to.equal(5);
+
+    const oldestValue = await cache.getValue('1');
+    expect(oldestValue).to.equal(undefined);
+
+    // restore
+    LocalCache['DEFAULT_MAX_ITEMS'] = origMax;
+
+  })
+
+  it('can get the remaining TTL of an item', async () => {
+    const cache = new LocalCache();
+    const wasSet = await cache.setValue('key', 'value', 10 * 60);
+    const cacheTtl = await cache.getTtl('key'); // returns ttl in ms
+
+    expect(wasSet).to.be.true;
+    expect(cacheTtl).to.exist;
+    expect(cacheTtl).to.be.within(9 * 60 * 1000, 10 * 60 * 1000);
+  });
+
+  it('returns undefined when we call getTtl if the item does not exist in the cache', async () => {
+    const cache = new LocalCache();
+    const cacheTtl = await cache.getTtl('key');
+
+    expect(cacheTtl).to.be.undefined;
+  });
+
+  it('returns 0 when we call getTtl if the item does not expire', async () => {
+    const cache = new LocalCache();
+    const wasSet = await cache.setValue('key', 'value');
+    const cacheTtl = await cache.getTtl('key');
+
+    expect(wasSet).to.be.true;
+    expect(cacheTtl).to.equal(0);
+  });
+
+});
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}