feat: add input validation to go() method

Author: andrewshell

src/index.ts

@@ -21,6 +21,20 @@ export class Cacheism {
     status: number,
     callback: (existing: Hit | Miss) => Promise<unknown>
   ): Promise<Hit | Miss> {
+    // Input validation
+    if (typeof cacheDomain !== 'string') {
+      throw new TypeError('cacheDomain must be a string');
+    }
+    if (typeof cachePath !== 'string') {
+      throw new TypeError('cachePath must be a string');
+    }
+    if (typeof status !== 'number' || status < 0 || status > 3) {
+      throw new TypeError('status must be a valid Status value (0-3)');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError('callback must be a function');
+    }
+
     const name = this.cacheName(cacheDomain, cachePath);
     let existing: Hit | Miss = new Miss(name, 'Missing cache', 0);
     const hasCache = await this.store.isset(name);

test/validation.cjs

@@ -0,0 +1,204 @@
+const expect = require('expect.js');
+
+const { Cacheism } = require('../dist/index.cjs');
+const cache = new Cacheism(Cacheism.store.memory());
+
+describe('input validation', function() {
+
+  describe('cacheDomain', function() {
+
+    it('should throw TypeError when cacheDomain is null', async function() {
+      try {
+        await cache.go(null, 'path', Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cacheDomain must be a string');
+      }
+    });
+
+    it('should throw TypeError when cacheDomain is undefined', async function() {
+      try {
+        await cache.go(undefined, 'path', Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cacheDomain must be a string');
+      }
+    });
+
+    it('should throw TypeError when cacheDomain is a number', async function() {
+      try {
+        await cache.go(123, 'path', Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cacheDomain must be a string');
+      }
+    });
+
+    it('should throw TypeError when cacheDomain is an object', async function() {
+      try {
+        await cache.go({}, 'path', Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cacheDomain must be a string');
+      }
+    });
+
+  });
+
+  describe('cachePath', function() {
+
+    it('should throw TypeError when cachePath is null', async function() {
+      try {
+        await cache.go('domain', null, Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cachePath must be a string');
+      }
+    });
+
+    it('should throw TypeError when cachePath is undefined', async function() {
+      try {
+        await cache.go('domain', undefined, Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cachePath must be a string');
+      }
+    });
+
+    it('should throw TypeError when cachePath is a number', async function() {
+      try {
+        await cache.go('domain', 123, Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cachePath must be a string');
+      }
+    });
+
+    it('should throw TypeError when cachePath is an array', async function() {
+      try {
+        await cache.go('domain', [], Cacheism.Status.onlyFresh, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('cachePath must be a string');
+      }
+    });
+
+  });
+
+  describe('status', function() {
+
+    it('should throw TypeError when status is negative', async function() {
+      try {
+        await cache.go('domain', 'path', -1, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('status must be a valid Status value (0-3)');
+      }
+    });
+
+    it('should throw TypeError when status is greater than 3', async function() {
+      try {
+        await cache.go('domain', 'path', 4, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('status must be a valid Status value (0-3)');
+      }
+    });
+
+    it('should throw TypeError when status is a string', async function() {
+      try {
+        await cache.go('domain', 'path', 'onlyFresh', async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('status must be a valid Status value (0-3)');
+      }
+    });
+
+    it('should throw TypeError when status is null', async function() {
+      try {
+        await cache.go('domain', 'path', null, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('status must be a valid Status value (0-3)');
+      }
+    });
+
+    it('should throw TypeError when status is undefined', async function() {
+      try {
+        await cache.go('domain', 'path', undefined, async () => 'data');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('status must be a valid Status value (0-3)');
+      }
+    });
+
+  });
+
+  describe('callback', function() {
+
+    it('should throw TypeError when callback is null', async function() {
+      try {
+        await cache.go('domain', 'path', Cacheism.Status.onlyFresh, null);
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('callback must be a function');
+      }
+    });
+
+    it('should throw TypeError when callback is undefined', async function() {
+      try {
+        await cache.go('domain', 'path', Cacheism.Status.onlyFresh, undefined);
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('callback must be a function');
+      }
+    });
+
+    it('should throw TypeError when callback is a string', async function() {
+      try {
+        await cache.go('domain', 'path', Cacheism.Status.onlyFresh, 'not a function');
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('callback must be a function');
+      }
+    });
+
+    it('should throw TypeError when callback is a number', async function() {
+      try {
+        await cache.go('domain', 'path', Cacheism.Status.onlyFresh, 123);
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('callback must be a function');
+      }
+    });
+
+    it('should throw TypeError when callback is an object', async function() {
+      try {
+        await cache.go('domain', 'path', Cacheism.Status.onlyFresh, {});
+        expect().fail('Expected TypeError to be thrown');
+      } catch (err) {
+        expect(err).to.be.a(TypeError);
+        expect(err.message).to.be('callback must be a function');
+      }
+    });
+
+  });
+
+});