feat: Handling for node-like callback functions

.gitignore

@@ -0,0 +1 @@
+coverage

index.js

@@ -13,4 +13,7 @@ const defaults = {
 function circuitBreaker (action, options) {
   return new CircuitBreaker(action, Object.assign({}, defaults, options));
 }
+
+circuitBreaker.promisify = require('./lib/promisify');
+
 module.exports = exports = circuitBreaker;

lib/promisify.js

@@ -0,0 +1,15 @@
+const Fidelity = require('fidelity');
+
+module.exports = exports = function promisify (func) {
+  return function promisifiedFunction () {
+    return new Fidelity((resolve, reject) => {
+      const cb = (err, result) => {
+        if (err) reject(err);
+        resolve(result);
+      };
+      const args = Array.prototype.slice.call(arguments);
+      args.push(cb);
+      func.apply(func, args);
+    });
+  };
+};

test/test.js

@@ -4,6 +4,7 @@ const circuitBreaker = require('../');
 
 test('api', (t) => {
   const breaker = circuitBreaker(passFail);
+  t.ok(circuitBreaker.promisify);
   t.ok(breaker);
   t.ok(breaker.fire);
   t.notOk(breaker.open);
@@ -25,6 +26,26 @@ test('Passes arguments to the circuit function', (t) => {
     .catch(t.fail);
 });
 
+test('Fails when the circuit function fails', (t) => {
+  const expected = -1;
+  const breaker = circuitBreaker(passFail);
+
+  breaker.fire(expected)
+    .then(t.fail)
+    .catch((e) => t.equals(e, expected))
+    .then(t.end);
+});
+
+test('Fails when the circuit function times out', (t) => {
+  const expected = 'Action timed out after 10ms';
+  const breaker = circuitBreaker(slowFunction, { timeout: 10 });
+
+  breaker.fire()
+    .then(t.fail)
+    .catch((e) => t.equals(e, expected))
+    .then(t.end);
+});
+
 test('Works with functions that do not return a promise', (t) => {
   const breaker = circuitBreaker(nonPromise);
 
@@ -43,32 +64,23 @@ test('Works with non-functions', (t) => {
     .catch(t.fail);
 });
 
-test.skip('Works with callback functions', (t) => {
-  const breaker = circuitBreaker(callbackFunction);
+test('Works with callback functions', (t) => {
+  const promisified = circuitBreaker.promisify(callbackFunction);
+  const breaker = circuitBreaker(promisified);
 
   breaker.fire(3, 4)
     .then((arg) => t.equals(arg, 7))
     .then(t.end)
     .catch(t.fail);
 });
 
-test('Fails when the circuit function fails', (t) => {
-  const expected = -1;
-  const breaker = circuitBreaker(passFail);
-
-  breaker.fire(expected)
-    .then(t.fail)
-    .catch((e) => t.equals(e, expected))
-    .then(t.end);
-});
+test('Works with callback functions that fail', (t) => {
+  const promisified = circuitBreaker.promisify(failedCallbackFunction);
+  const breaker = circuitBreaker(promisified);
 
-test('Fails when the circuit function times out', (t) => {
-  const expected = 'Action timed out after 10ms';
-  const breaker = circuitBreaker(slowFunction, { timeout: 10 });
-
-  breaker.fire()
+  breaker.fire(3, 4)
     .then(t.fail)
-    .catch((e) => t.equals(e, expected))
+    .catch((e) => t.equals(e, 'Whoops!'))
     .then(t.end);
 });
 
@@ -122,7 +134,7 @@ test('Executes fallback action, if one exists, when breaker is open', (t) => {
     });
 });
 
-test('Passes arguments to fallback function', (t) => {
+test('Passes arguments to the fallback function', (t) => {
   const fails = -1;
   const expected = 100;
   const breaker = circuitBreaker(passFail, { maxFailures: 1 });
@@ -168,5 +180,9 @@ function nonPromise () {
 }
 
 function callbackFunction (x, y, callback) {
-  callback(x + y);
+  callback(null, x + y);
+}
+
+function failedCallbackFunction () {
+  Array.prototype.slice.call(arguments).pop()('Whoops!');
 }