react 0.2.4 → 0.3.4

package/test/core-promised.test.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+   Test core PromiseTasks using promised-io
+  */
+
+var test = require('tap').test;
+//var when = require('promised-io/promise');
+var Deferred = require('promised-io/promise').Deferred;
+
+var react = require('../');  //require('react');
+
+
+function multiply(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x * y);
+  }, 10);
+  return deferred.promise;
+}
+function add(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x + y);
+  }, 10);
+  return deferred.promise;
+}
+
+function badFunc(a, b) {
+  throw new Error('badFuncThrow');
+}
+
+function badF2(a, b) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.reject(new Error('my-error'));
+  }, 10);
+  return deferred.promise;
+}
+
+
+test('multi-step', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 9);
+    t.end();
+  });
+});  
+
+test('using "this" in a cb function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    var deferred = new Deferred();
+    var self = this;
+    setTimeout(function () {
+      deferred.resolve(self.a);
+    }, 10);
+    return deferred.promise;
+  }
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'], type: 'promise' }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+test('throws error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'badFuncThrow');
+    t.end();
+  });
+});
+
+test('rejects with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
+      { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});

package/test/core-when.test.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+   Test core WhenTasks using promised-io
+  */
+
+var test = require('tap').test;
+//var when = require('promised-io/promise');
+var Deferred = require('promised-io/promise').Deferred;
+
+var react = require('../');  //require('react');
+
+
+function multiply(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x * y);
+  }, 10);
+  return deferred.promise;
+}
+function add(x, y) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.resolve(x + y);
+  }, 10);
+  return deferred.promise;
+}
+
+function badF2(a, b) {
+  var deferred = new Deferred();
+  setTimeout(function () {
+    deferred.reject(new Error('my-error'));
+  }, 10);
+  return deferred.promise;
+}
+
+
+test('multi-step', function (t) {
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['pm', 'pa'],
+    tasks: [    
+      { a: ['pm'], out: ['m'], type: 'when' },
+      { a: ['pa'], out: ['a'], type: 'when' }
+    ],
+    outTask: { a: ['m', 'a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var pm = multiply(2, 3);
+  var pa = add(4, 5);
+  
+  fn(pm, pa, function (err, m, a) {
+    t.equal(err, null);
+    t.equal(m, 6);
+    t.equal(a, 9);
+    t.end();
+  });
+});  
+
+
+test('rejects with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['pm', 'pa'],
+    tasks: [    
+      { a: ['pm'], out: ['m'], type: 'when' },
+      { a: ['pa'], out: ['a'], type: 'when' }
+    ],
+    outTask: { a: ['m', 'a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var pm = badF2(2, 3);
+  var pa = add(4, 5);
+
+  
+  fn(pm, pa, function (err, m, a) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});

package/test/core.test.js

@@ -3,6 +3,7 @@
 var test = require('tap').test;
 
 var react = require('../react');
+var EventCollector = require('../lib/track-tasks').EventCollector;  // require('react/lib/track-tasks'); // turn on tracking
 
 function multiply(x, y, cb) { cb(null, x * y); }
 function add(x, y, cb) { cb(null, x + y); }
@@ -107,19 +108,17 @@ test('multi-step with after as nonarr fn', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
   
   fn(2, 3, function (err, c, d) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(d, 5);
+    var events = collector.list();
     t.equal(events.length, 2, 'should have seen one task compl events');
-    t.equal(events[0].name, 'add', 'name matches');
-    t.equal(events[1].name, 'multiply', 'name matches');
+    t.equal(events[0].task.name, 'add', 'name matches');
+    t.equal(events[1].task.name, 'multiply', 'name matches');
     t.end();
   });
 });  
@@ -137,31 +136,29 @@ test('mixed multi-step with after as nonarr fn w/events', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
   
   fn(2, 3, function (err, c, d) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(d, 5);
+    var events = collector.list();
     t.equal(events.length, 2, 'should have seen one task compl events');
-    t.equal(events[0].name, 'fnRetsSum', 'name matches');
-    t.ok(events[0].id, 'has unique id');
-    t.ok(events[0].startTime, 'has startTime');
-    t.ok(events[0].endTime, 'has endTime');
-    t.ok(events[0].elapsedTime !== undefined, 'has elapsedTime');    
-    t.ok(events[0].args, 'has args');
-    t.ok(events[0].results, 'has results');
-    t.equal(events[1].name, 'multiply', 'name matches');
-    t.ok(events[1].id, 'has unique id');
-    t.ok(events[1].startTime, 'has startTime');
-    t.ok(events[1].endTime, 'has endTime');
-    t.ok(events[1].elapsedTime !== undefined, 'has elapsedTime');    
-    t.ok(events[1].args, 'has args');
-    t.ok(events[1].results, 'has results');
+    t.equal(events[0].task.name, 'fnRetsSum', 'name matches');
+    t.ok(events[0].task.id, 'has unique id');
+    t.ok(events[0].task.startTime, 'has startTime');
+    t.ok(events[0].task.endTime, 'has endTime');
+    t.ok(events[0].task.elapsedTime !== undefined, 'has elapsedTime');    
+    t.ok(events[0].task.args, 'has args');
+    t.ok(events[0].task.results, 'has results');
+    t.equal(events[1].task.name, 'multiply', 'name matches');
+    t.ok(events[1].task.id, 'has unique id');
+    t.ok(events[1].task.startTime, 'has startTime');
+    t.ok(events[1].task.endTime, 'has endTime');
+    t.ok(events[1].task.elapsedTime !== undefined, 'has elapsedTime');    
+    t.ok(events[1].task.args, 'has args');
+    t.ok(events[1].task.results, 'has results');
     t.end();
   });
 });  
@@ -377,7 +374,66 @@ test('multi-step func cb err, cb with error', function (t) {
     t.end();
   });
 });  
+
+test('using "this" in a cb function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    cb(null, this.a);
+  }
   
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'] }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+test('using "this" in a sync function', function (t) {
+  t.plan(3);
+  function getA(cb) {
+    /*jshint validthis: true */
+    return this.a;
+  }
+  
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: [],
+    tasks: [    
+      { f: getA, a: [], out: ['a'], type: 'ret' }
+    ],
+    outTask: { a: ['a'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var obj = {
+      a: 100
+  };
+
+  fn.apply(obj, [function (err, a) {
+    t.equal(err, null);
+    t.equal(a, 100);
+    t.end();
+  }]);
+});
+
+
+// Select first tests
+
 
 test('selectFirst with first succeeding', function (t) {
   t.plan(6);
@@ -392,18 +448,16 @@ test('selectFirst with first succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 6);
+    var events = collector.list();
     t.equal(events.length, 1, 'should have seen one task compl events');
-    t.equal(events[0].name, 'multiply', 'name matches');
-    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[0].task.name, 'multiply', 'name matches');
+    t.deepEqual(events[0].task.results, [6], 'results match');
     t.end();
   });
 });  
@@ -425,18 +479,16 @@ test('selectFirst with third succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[2].name, 'add', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[2].task.name, 'add', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });  
@@ -462,20 +514,18 @@ test('selectFirst forces order with third succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[0].name, 'noSuccess', 'name matches');
-    t.equal(events[1].name, 'noSuccessNull', 'name matches');
-    t.equal(events[2].name, 'add', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[0].task.name, 'noSuccess', 'name matches');
+    t.equal(events[1].task.name, 'noSuccessNull', 'name matches');
+    t.equal(events[2].task.name, 'add', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });  
@@ -501,18 +551,16 @@ test('selectFirst using direct returns', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[2].name, 'addRet', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[2].task.name, 'addRet', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });