@withjoy/limiter 0.1.2 → 0.1.4-test

package/limitd-redis/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "limitd-redis",
+  "version": "7.8.1",
+  "description": "A database client for limits on top of redis",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/auth0/limitd-redis.git"
+  },
+  "scripts": {
+    "test": "trap 'docker-compose down --remove-orphans -v' EXIT; docker-compose up -d && NODE_ENV=test nyc mocha --exit"
+  },
+  "author": "Auth0",
+  "license": "MIT",
+  "dependencies": {
+    "async": "^2.6.1",
+    "disyuntor": "^3.5.0",
+    "ioredis": "^4.28.5",
+    "lodash": "^4.17.15",
+    "lru-cache": "^4.1.5",
+    "ms": "^2.1.2",
+    "retry": "^0.12.0"
+  },
+  "devDependencies": {
+    "chai": "^4.1.2",
+    "eslint": "^6.1.0",
+    "mocha": "^5.2.0",
+    "nyc": "^14.1.1",
+    "toxiproxy-node-client": "^2.0.6"
+  }
+}

package/limitd-redis/test/cb.tests.js

@@ -0,0 +1,124 @@
+var assert = require('assert'),
+  cb = require('../lib/cb');
+
+function invokeAsync(callback) {
+  setTimeout(function() {
+    callback(null, 'foo');
+  }, 100);
+}
+
+function invokeAsyncError(callback) {
+  setTimeout(function() {
+    callback(new Error());
+  }, 100);
+}
+
+function invokeAsyncTwice(callback) {
+  setTimeout(function() {
+    callback(null, 'foo');
+    callback(null, 'foo');
+  }, 100);
+}
+
+describe('cb(callback)', function() {
+
+  it('should invoke the provided callback', function(done) {
+    invokeAsync(cb(function(err, res) {
+      assert.strictEqual(res, 'foo');
+      done();
+    }));
+  });
+
+  it('shouldn\'t mess with errors', function(done) {
+    invokeAsyncError(cb(function(err, res) {
+      assert(err);
+      done();
+    }));
+  });
+
+  it('should allow multiple executions', function(done) {
+    var count = 0;
+    invokeAsyncTwice(cb(function(err, res) {
+      count++;
+      if (count === 2) done();
+    }));
+  });
+
+});
+
+describe('cb(callback).timeout(ms)', function() {
+	
+  it('should complete successfully within timeout period', function(done) {
+    invokeAsync(cb(function(err, res) {
+      assert.strictEqual(res, 'foo');
+      done();
+    }).timeout(200));
+  });
+
+  it('should complete with an error after timeout period', function(done) {
+    invokeAsync(cb(function(err, res) {
+      assert(err);
+      done();
+    }).timeout(50));
+  });
+
+  it('error resulting from a timeout should be instanceof cb.TimeoutError', function(done) {
+    invokeAsync(cb(function(err, res) {
+      assert(err instanceof cb.TimeoutError);
+      done();
+    }).timeout(50));
+  });
+});
+
+describe('cb(callback).error(errback)', function() {
+
+  it('should skip the err argument when invoking callback', function(done) {
+    invokeAsync(cb(function(res) {
+      assert.strictEqual(res, 'foo');
+      done();
+    }).error(assert.ifError));
+  });
+
+  it('should pass errors to provided errback', function(done) {
+    invokeAsyncError(cb(function(res) {
+      throw new Error('should not be invoked');
+    }).error(function(err) {
+      assert(err);
+      done();
+    }));
+  });
+
+});
+
+describe('cb(callback).error(errback).timeout(ms)', function() {
+
+  it('should skip the err argument when invoking callback', function(done) {
+    invokeAsync(cb(function(res) {
+      assert.strictEqual(res, 'foo');
+      done();
+    }).error(assert.ifError).timeout(200));
+  });
+
+  it('should pass timeout error to provided errback', function(done) {
+    invokeAsyncError(cb(function(res) {
+      throw new Error('should not be invoked');
+    }).error(function(err) {
+      assert(err);
+      done();
+    }).timeout(50));
+  });
+
+});
+
+describe('cb(callback).once()', function() {
+
+  it('should allow multiple executions', function(done) {
+    var count = 0;
+    invokeAsyncTwice(cb(function(err, res) {
+      count++;
+      assert.notEqual(count, 2);
+      setTimeout(done, 100);
+    }).once());
+  });
+
+});

package/limitd-redis/test/client.tests.js

@@ -0,0 +1,194 @@
+/* eslint-env node, mocha */
+const _ = require('lodash');
+const assert = require('chai').assert;
+const LimitRedis = require('../lib/client');
+const ValidationError = LimitRedis.ValidationError;
+
+describe('LimitdRedis', () => {
+  let client;
+  beforeEach((done) => {
+    client = new LimitRedis({ uri: 'localhost', buckets: {}, prefix: 'tests:' });
+    client.on('error', done);
+    client.on('ready', done);
+  });
+
+  describe('#constructor', () => {
+    it('should call error if db fails', (done) => {
+      let called = false; // avoid uncaught
+      client = new LimitRedis({ uri: 'localhost:fail', buckets: {} });
+      client.on('error', () => {
+        if (!called) {
+          called = true;
+          return done();
+        }
+      });
+    });
+
+    it('should set up retry and circuitbreaker defaults', () => {
+      assert.equal(client.retryOpts.retries, 3);
+      assert.equal(client.retryOpts.minTimeout, 10);
+      assert.equal(client.retryOpts.maxTimeout, 30);
+      assert.equal(client.breakerOpts.timeout, '0.25s');
+      assert.equal(client.breakerOpts.maxFailures, 50);
+      assert.equal(client.breakerOpts.cooldown, '1s');
+      assert.equal(client.breakerOpts.maxCooldown, '3s');
+      assert.equal(client.breakerOpts.name, 'limitr');
+      assert.equal(client.commandTimeout, 75);
+    });
+
+    it('should accept circuitbreaker parameters', () => {
+      client = new LimitRedis({ uri: 'localhost', buckets: {}, circuitbreaker: { onTrip: () => {} } });
+      assert.ok(client.breakerOpts.onTrip);
+    });
+
+    it('should accept retry parameters', () => {
+      client = new LimitRedis({ uri: 'localhost', buckets: {}, retry: { retries: 5 } });
+      assert.equa;(client.retryOpts.retries, 5);
+    });
+  });
+
+  describe('#handler', () => {
+    it('should handle count & cb-less calls', (done) => {
+      client.db.take = (params, cb) => {
+        cb();
+        done();
+      };
+      client.handler('take', 'test', 'test', 1);
+    });
+    it('should handle count-less & cb-less calls', (done) => {
+      client.db.take = (params, cb) => {
+        cb();
+        done();
+      };
+      client.handler('take', 'test', 'test');
+    });
+    it('should handle count-less & cb calls', (done) => {
+      client.db.take = (params, cb) => {
+        cb();
+      };
+      client.handler('take', 'test', 'test', done);
+    });
+    it('should not retry or circuitbreak on ValidationError', (done) => {
+      client = new LimitRedis({ uri: 'localhost', buckets: {}, circuitbreaker: { maxFailures: 3, onTrip: () => {} } });
+      client.db.take = (params, cb) => {
+        return cb(new ValidationError('invalid config'));
+      };
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', _.noop);
+      client.handler('take', 'invalid', 'test', (err) => {
+        assert.notEqual(err.message, 'limitr: the circuit-breaker is open');
+        assert.equal(err.message, 'invalid config');
+        done();
+      });
+    });
+    it('should retry on redis errors', (done) => {
+      let calls = 0;
+      client.db.take = (params, cb) => {
+        if (calls === 0) {
+          calls++;
+          return cb(new Error());
+        }
+        return cb();
+      };
+      client.handler('take', 'test', 'test', done);
+    });
+    it('should retry on timeouts against redis', (done) => {
+      let calls = 0;
+      client.db.take = (params, cb) => {
+        if (calls === 0) {
+          calls++;
+          return;
+        }
+        assert.equal(calls, 1);
+        return cb();
+      };
+      client.handler('take', 'test', 'test', done);
+    });
+    it('should circuitbreak', (done) => {
+      client = new LimitRedis({ uri: 'localhost', buckets: {}, circuitbreaker: { maxFailures: 3, onTrip: () => {} } });
+      client.db.take = () => {};
+      client.handler('take', 'test', 'test', _.noop);
+      client.handler('take', 'test', 'test', _.noop);
+      client.handler('take', 'test', 'test', _.noop);
+      client.handler('take', 'test', 'test', _.noop);
+      client.handler('take', 'test', 'test', _.noop);
+      client.handler('take', 'test', 'test', () => {
+        client.handler('take', 'test', 'test', (err) => {
+          assert.equal(err.message, 'limitr: the circuit-breaker is open');
+          done();
+        });
+      });
+    });
+  });
+
+  describe('#take', () => {
+    it('should call #handle with take as the method', (done) => {
+      client.handler = (method, type, key, count, cb) => {
+        assert.equal(method, 'take');
+        cb();
+      };
+      client.take('test', 'test', 1, done);
+    });
+  });
+
+  describe('#wait', () => {
+    it('should call #handle with take as the method', (done) => {
+      client.handler = (method, type, key, count, cb) => {
+        assert.equal(method, 'wait');
+        cb();
+      };
+      client.wait('test', 'test', 1, done);
+    });
+  });
+
+  describe('#put', () => {
+    it('should call #handle with take as the method', (done) => {
+      client.handler = (method, type, key, count, cb) => {
+        assert.equal(method, 'put');
+        cb();
+      };
+      client.put('test', 'test', 1, done);
+    });
+  });
+
+  describe('#get', () => {
+    it('should call #handle with get as the method', (done) => {
+      client.handler = (method, type, key, cb) => {
+        assert.equal(method, 'get');
+        cb();
+      };
+      client.get('test', 'test', done);
+    });
+  });
+
+  describe('#reset', () => {
+    it('should call #put', (done) => {
+      client.put = (type, key, count, cb) => {
+        cb();
+      };
+      client.reset('test', 'test', 1, done);
+    });
+  });
+
+  describe('#resetAll', () => {
+    it('should call db.resetAll', (done) => {
+      client.db.resetAll = (cb) => cb();
+      client.resetAll(done);
+    });
+  });
+
+  describe('#close', () => {
+    it('should call db.close', (done) => {
+      client.db.close = (cb) => cb();
+      client.close((err) => {
+        assert.equal(client.db.listenerCount('error'), 0);
+        assert.equal(client.db.listenerCount('ready'), 0);
+        done(err);
+      });
+    });
+  });
+});