cachette 4.0.12 → 4.0.14

package/test/LocalCache_test.ts

@@ -2,9 +2,7 @@ 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');
@@ -50,13 +48,12 @@ describe('LocalCache', () => {
 
   it('can set values with expiry', async () => {
     const cache = new LocalCache();
-    await cache.setValue('key', 'value', .2);
+    await cache.setValue('key', 'value', 0.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 () => {
@@ -67,7 +64,6 @@ describe('LocalCache', () => {
     await cache.delValue('key');
 
     expect(await cache.getValue('key')).not.to.exist;
-
   });
 
   it('will not grow in size past the maximum size', async () => {
@@ -92,8 +88,7 @@ describe('LocalCache', () => {
 
     // restore
     LocalCache['DEFAULT_MAX_ITEMS'] = origMax;
-
-  })
+  });
 
   it('can get the remaining TTL of an item', async () => {
     const cache = new LocalCache();
@@ -120,7 +115,6 @@ describe('LocalCache', () => {
     expect(wasSet).to.be.true;
     expect(cacheTtl).to.equal(0);
   });
-
 });
 
 function sleep(ms: number): Promise<void> {

package/test/RedisCache_test.ts

@@ -3,9 +3,7 @@ import * as sinon from 'sinon';
 
 import { RedisCache, SIZE_THRESHOLD_WARNING_BYTES } from '../src/lib/RedisCache';
 
-
 describe('RedisCache', () => {
-
   describe('constructor', () => {
     it('will not crash the application given an invalid Redis URL', async () => {
       let cache = new RedisCache('redis://localhost:9999');
@@ -17,20 +15,15 @@ describe('RedisCache', () => {
     });
 
     it('will raise an error if given a Redis URL without protocol', async () => {
-      expect(
-        () => new RedisCache('rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com'),
-      ).to.throw();
+      expect(() => new RedisCache('rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com')).to.throw();
     });
 
     it('will raise an error if given a Redis URL with an invalid protocol', async () => {
-      expect(
-        () => new RedisCache('potato://rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com'),
-      ).to.throw();
+      expect(() => new RedisCache('potato://rer17kq3qdwc5wmy.4gzf3f.ng.0001.use1.cache.amazonaws.com')).to.throw();
     });
   });
 
   describe('value serialization', () => {
-
     it('can serialize the null value', () => {
       let value = RedisCache.serializeValue(null);
       expect(value).to.equal(RedisCache.NULL_VALUE);
@@ -58,12 +51,15 @@ describe('RedisCache', () => {
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested map', () => {
-      const mapStructure: Map<string, {
-        checksum: number;
-        originCommentId?: string;
-      }> = new Map();
+      const mapStructure: Map<
+        string,
+        {
+          checksum: number;
+          originCommentId?: string;
+        }
+      > = new Map();
       mapStructure.set('key1', { checksum: 1, originCommentId: 'c1' });
       mapStructure.set('key2', { checksum: 2, originCommentId: 'c2' });
       const obj = {
@@ -83,7 +79,7 @@ describe('RedisCache', () => {
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested set', () => {
       const setStructure: Set<string> = new Set();
       setStructure.add('key1');
@@ -124,7 +120,6 @@ describe('RedisCache', () => {
       const value = RedisCache.deserializeValue(null);
       expect(value).to.equal(undefined);
     });
-
   });
 
   describe('setValue', async () => {
@@ -237,7 +232,10 @@ describe('RedisCache', () => {
       const key = `emits-warning-on-large-value-${Math.random()}`;
       await cache.setValue(key, 'a'.repeat(SIZE_THRESHOLD_WARNING_BYTES));
 
-      const warningsAfterSetLargeKey = warnSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('Writing large value to Redis!'));
+      const warningsAfterSetLargeKey = warnSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('Writing large value to Redis!'));
       expect(warningsAfterSetLargeKey.length).to.equal(1);
     });
 
@@ -254,13 +252,15 @@ describe('RedisCache', () => {
       const key = `doesnt-emit-warning-on-small-value-${Math.random()}`;
       await cache.setValue(key, 'a'.repeat(SIZE_THRESHOLD_WARNING_BYTES - 1));
 
-      const warningsAfterSetLargeKey = warnSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('Writing large value to Redis!'));
+      const warningsAfterSetLargeKey = warnSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('Writing large value to Redis!'));
       expect(warningsAfterSetLargeKey.length).to.equal(0);
     });
   });
 
   describe('itemCount', async () => {
-
     it('can count the items in the redis cache.', async function (): Promise<void> {
       if (!process.env.TEST_REDIS_URL) {
         this.skip();
@@ -293,7 +293,7 @@ describe('RedisCache', () => {
       await cache.clear();
 
       await cache.setValue('test1', 'value1');
-      
+
       const replicationAcknowledged = await cache.waitForReplication(0, 50);
 
       // No replicas so we expect 0. This test basically confirms that waitForReplication doesn't crash. 🤷‍♂️

package/test/WriteThroughCache_test.ts

@@ -11,24 +11,18 @@ function makeFakeWriteThroughCache(): WriteThroughCache {
   return cache;
 }
 
-
 describe('WriteThroughCache', () => {
-
   it('will fallback to using a local cache is no connection to redis is made', async () => {
-
     const cache = new WriteThroughCache('redis://localhost:9999');
 
     // We know the connection was not made, but we should still be able to use the local cache.
     await cache.setValue('key', 'value');
     const value = await cache.getValue('key');
     expect(value).to.equal('value');
-
   });
 
   describe('setValue', () => {
-
     it('will write the value in both caches', async () => {
-
       const cache = makeFakeWriteThroughCache();
 
       const response = await cache.setValue('key', 'value');
@@ -42,15 +36,11 @@ describe('WriteThroughCache', () => {
 
       value = await cache['redisCacheForReading'].getValue('key');
       expect(value).to.equal('value');
-
     });
-
   });
 
   describe('getValue', () => {
-
     it('will populate the local cache with right ttl when fetching from redis', async function (): Promise<void> {
-
       if (!process.env.TEST_REDIS_URL) {
         this.skip();
       }
@@ -64,15 +54,18 @@ describe('WriteThroughCache', () => {
 
       let value = await cache.getValue('key');
       expect(value).to.equal('value');
-      sinon.assert.calledWith(spy, 'key', 'value', sinon.match(ttl => ttl > 99.9 && ttl <= 100));
+      sinon.assert.calledWith(
+        spy,
+        'key',
+        'value',
+        sinon.match((ttl) => ttl > 99.9 && ttl <= 100),
+      );
 
       value = await cache['localCache'].getValue('key');
       expect(value).to.equal('value');
-
     });
 
     it('will get directly from the local cache if available', async () => {
-
       const cache = makeFakeWriteThroughCache();
 
       await cache['localCache'].setValue('key', 'value');
@@ -82,11 +75,9 @@ describe('WriteThroughCache', () => {
 
       value = await cache['redisCacheForReading'].getValue('key');
       expect(value).not.to.exist;
-
     });
 
     it('will populate the local cache for a null value', async () => {
-
       const cache = makeFakeWriteThroughCache();
 
       await cache['redisCacheForWriting'].setValue('key', null);
@@ -96,11 +87,9 @@ describe('WriteThroughCache', () => {
 
       value = await cache['localCache'].getValue('key');
       expect(value).to.equal(null);
-
     });
 
     it('will populate the local cache for an empty string', async () => {
-
       const cache = makeFakeWriteThroughCache();
 
       await cache['redisCacheForWriting'].setValue('key', '');
@@ -110,7 +99,6 @@ describe('WriteThroughCache', () => {
 
       value = await cache['localCache'].getValue('key');
       expect(value).to.equal('');
-
     });
 
     it('returns nothing if value in cache has expired', async function (): Promise<void> {
@@ -120,17 +108,14 @@ describe('WriteThroughCache', () => {
       const cache = new WriteThroughCache(process.env.TEST_REDIS_URL as string);
       await cache.setValue('fakeKey', 'fakeValue', 0.1);
       // sleep 100 ms
-      await new Promise(resolve => setTimeout(resolve, 150));
+      await new Promise((resolve) => setTimeout(resolve, 150));
       const fakeValue = await cache.getValue('fakeKey');
       expect(fakeValue).to.be.undefined;
     });
-
   });
 
   describe('delValue', () => {
-
     it('will delete values from both caches', async () => {
-
       const cache = makeFakeWriteThroughCache();
 
       await cache.setValue('key', 'value');
@@ -148,30 +133,26 @@ describe('WriteThroughCache', () => {
 
       value = await cache['localCache'].getValue('key');
       expect(value).not.to.exist;
-
     });
-
   });
 
   describe('clear', () => {
-
     it('clears from both caches', async () => {
       const cache = makeFakeWriteThroughCache();
 
       const base = [...Array(10).keys()];
-      await Promise.all(base.map(i => cache.setValue(`key${i}`, i)));
+      await Promise.all(base.map((i) => cache.setValue(`key${i}`, i)));
       expect(await cache.itemCount()).to.equal(20);
 
-      let values = await Promise.all(base.map(i => cache.getValue(`key${i}`)));
+      let values = await Promise.all(base.map((i) => cache.getValue(`key${i}`)));
       expect(values.sort()).to.eql(base);
 
       await cache.clear();
       expect(await cache.itemCount()).to.equal(0);
 
-      values = await Promise.all(base.map(i => cache.getValue(`key${i}`)));
-      values.forEach(value => expect(value).to.be.undefined);
+      values = await Promise.all(base.map((i) => cache.getValue(`key${i}`)));
+      values.forEach((value) => expect(value).to.be.undefined);
     });
-
   });
 
   describe('metrics', () => {
@@ -187,7 +168,7 @@ describe('WriteThroughCache', () => {
     afterEach(() => {
       delete process.env.CACHETTE_METRICS_PERIOD_MINUTES;
       sinonClock.restore();
-    })
+    });
 
     it('stores metrics if env. var is set', async function () {
       if (!process.env.TEST_REDIS_URL) {
@@ -282,25 +263,39 @@ describe('WriteThroughCache', () => {
       await cache.getValue(key);
 
       // Testing we emitted at requested period
-      const metricsReports0 = infoSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('metrics'));
+      const metricsReports0 = infoSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('metrics'));
       expect(metricsReports0.length).to.equal(0);
 
       sinonClock.tick(59999); // t = 1min minus a millisecond
-      const metricsReports59s = infoSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('metrics'));
+      const metricsReports59s = infoSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('metrics'));
       expect(metricsReports59s.length).to.equal(0);
 
       sinonClock.tick(2); // t = 1min plus a millisecond
-      const metricsReports61s = infoSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('metrics'));
+      const metricsReports61s = infoSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('metrics'));
       expect(metricsReports61s.length).to.equal(1);
-      expect(metricsReports61s[0]).to.equal('WriteThroughCache metrics during last 1 min - Total: 3, Local hits: 1 (33%), Redis hits: 1 (33%), Double misses: 1 (33%).')
+      expect(metricsReports61s[0]).to.equal(
+        'WriteThroughCache metrics during last 1 min - Total: 3, Local hits: 1 (33%), Redis hits: 1 (33%), Double misses: 1 (33%).',
+      );
 
       // Causing no activity for a minute and testing we emit again
       sinonClock.tick(60000); // t = 2min plus a millisecond
-      const metricsReports121s = infoSpy.getCalls().map(c => c.firstArg).filter(msg => msg.includes('metrics'));
+      const metricsReports121s = infoSpy
+        .getCalls()
+        .map((c) => c.firstArg)
+        .filter((msg) => msg.includes('metrics'));
       expect(metricsReports121s.length).to.equal(2);
-      expect(metricsReports121s[1]).to.equal('WriteThroughCache metrics during last 1 min - Total: 0, Local hits: 0 (0%), Redis hits: 0 (0%), Double misses: 0 (0%).')
+      expect(metricsReports121s[1]).to.equal(
+        'WriteThroughCache metrics during last 1 min - Total: 0, Local hits: 0 (0%), Redis hits: 0 (0%), Double misses: 0 (0%).',
+      );
     });
-
   });
-
 });