react 0.2.3 → 0.3.0

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

@@ -377,7 +377,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);
@@ -398,7 +457,7 @@ test('selectFirst with first succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(events.length, 1, 'should have seen one task compl events');
@@ -431,7 +490,7 @@ test('selectFirst with third succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');
@@ -468,7 +527,7 @@ test('selectFirst forces order with third succeeding', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');
@@ -507,7 +566,7 @@ test('selectFirst using direct returns', function (t) {
   }
   fn.events.on('task.complete', accumEvents);
 
-  fn(2, 3, function (err, c, d) {
+  fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
     t.equal(events.length, 3, 'should have seen three task compl events');

package/test/dsl.test.js

@@ -77,6 +77,18 @@ test('single task, err and out params', function (t) {
   t.end();  
 });
 
+test('using - with literal string', function (t) {
+  var r = react('myName', '"hello-world", cb -> err, c',
+    falpha, '"another-string", cb -> err, c'
+  );
+  t.deepEqual(r.ast.inParams, ['"hello-world"']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['"another-string"'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, ERR and out params', function (t) {
   var r = react('myName', 'cb -> ERR, c', 
     falpha, 'cb -> ERR, c'
@@ -191,10 +203,62 @@ test('object prop task params', function (t) {
   t.end();  
 });
 
+// Errors
+
+test('missing name, throws error', function (t) {
+  var fn = function () {
+    var r = react('cb -> err, c',
+                  falpha, 'cb -> err, c'
+                 );
+  };
+  t.throws(fn, new Error('first flow parameter should be the flow name, but found in/out def: cb -> err, c'));
+  t.end();
+});
+
+test('missing err in flow in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> c',  // missing err
+                  falpha, 'cb -> err, c'
+                 );
+  };
+  t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+  t.end();
+});
+
+test('missing err in task in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> err, c',
+                  falpha, 'cb -> c'  // missing err
+                 );
+  };
+  t.throws(fn, new Error('callback specified, but first out param was not "err", use for clarity. Found in/out def: cb -> c'));
+  t.end();
+});
+
+test('found err, but missing cb/callback in flow in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'a -> err, c', // missing cb
+                  falpha, 'cb -> err, c'
+                 );
+  };
+  t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
+  t.end();
+});
+
+test('found err, but missing cb/callback in task in/out - force for consistency, throw error', function (t) {
+  var fn = function () {
+    var r = react('myname', 'cb -> err, c',
+                  falpha, 'a -> err, c'  // missing cb
+                 );
+  };
+  t.throws(fn, new Error('found err param, but cb/callback is not specified, is this cb-style async or sync function? Found in/out def: a -> err, c'));
+  t.end();
+});
+
 test('extra arg throws error', function (t) {
   var fn = function () {
     var r = react('myName', 'a, b, cb -> err, c, d', 
-      falpha, 'a -> err, c', { after: fbeta },
+      falpha, 'a, cb -> err, c', { after: fbeta },
       fbeta,  'a, b -> returns d',
       'extraBadArg'
     );
@@ -205,8 +269,8 @@ test('extra arg throws error', function (t) {
 
 test('not enough args throws error', function (t) {
   var fn = function () {
-    var r = react('myName', 'a, b, cb -> c, d', 
-      falpha, 'a -> err, c', { after: fbeta },
+    var r = react('myName', 'a, b, cb -> err, c, d', 
+      falpha, 'a, cb -> err, c', { after: fbeta },
       fbeta
     );
   };
@@ -215,6 +279,7 @@ test('not enough args throws error', function (t) {
 });
 
 test('long example', function (t) {
+  /*jshint white: false */
   t.plan(4);
   function loadUser(uid, cb){ setTimeout(cb, 100, null, "User"+uid); }
   function loadFile(filename, cb){ setTimeout(cb, 100, null, 'Filedata'+filename); }
@@ -247,7 +312,7 @@ test('long example', function (t) {
 // selectFirst 
 
 test('selectFirst', function (t) {
-  var r = react.selectFirst('myName', 'a, b, cb -> c',
+  var r = react.selectFirst('myName', 'a, b, cb -> err, c',
     { otherOptFoo: 'foo'},  // main options                            
     falpha, 'a, b, cb -> err, c',
     fbeta,  'a, b -> c'
@@ -262,4 +327,4 @@ test('selectFirst', function (t) {
   t.equal(r.ast.name, 'myName', 'name should match if supplied');
   t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
   t.end();  
-});
+});

package/test/{chain.test.js → dsl/chain.test.js}

@@ -3,7 +3,7 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var chainDefine = require('../lib/chain.js');
+var chainDefine = require('../../dsl/chain'); // require('react/dsl/chain');
 
 function falpha() { }
 function fbeta() { }
@@ -75,6 +75,19 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, err params', function (t) {
+  var fn = chainDefine()
+    .out('err')
+    .async(falpha).in().out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: [], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var fn = chainDefine()
     .out('err', 'c')
@@ -238,3 +251,73 @@ test('selectFirst', function (t) {
 });
 
 
+// full integration tests
+
+test('chainDefine use', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'm', 's')
+    .async(multiply).in('a', 'b', 'cb').out('err', 'm')
+    .async(add).in('m', 'a', 'cb').out('err', 's')
+    .end();
+
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].name, 'multiply', 'name matches');
+    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[1].name, 'add', 'name matches');
+    t.deepEqual(events[1].results, [8], 'results match');
+    t.end();
+  });
+});
+
+test('use chainDefine selectFirst with events', function (t) {
+  t.plan(7);
+  function noSuccess(a, b, cb) {
+    setTimeout(function () { cb(null); }, 100); // returns undefined result
+  }
+  function noSuccessNull(a, b, cb) { cb(null, null); } // returns null result
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+
+  var fn = chainDefine()
+    .selectFirst()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(noSuccess).in('a', 'b', 'cb').out('err', 'c')
+    .async(noSuccessNull).in('a', 'b', 'cb').out('err', 'c')
+    .async(add).in('a', 'b', 'cb').out('err', 'c')
+    .async(noSuccess).in('a', 'b', 'cb').out('err', 'c')
+    .end();
+  
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, c) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(c, 5);
+    t.equal(events.length, 3, 'should have seen two 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.end();
+  });
+});

package/test/{fstr.test.js → dsl/fstr.test.js}

@@ -3,7 +3,7 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var fstrDefine = require('../lib/fstr.js');
+var fstrDefine = require('../../dsl/fstr'); // require('react/dsl/fstr');
 
 function falpha() { }
 function fbeta() { }
@@ -59,6 +59,18 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, err params', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c'
+  ], 'err');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var r = fstrDefine('a, b', [
     falpha, 'a, b -> err, c'

package/test/{pcode.test.js → dsl/pcode.test.js}

@@ -3,7 +3,7 @@
 var test = require('tap').test;
 var sprintf = require('sprintf').sprintf;
 
-var pcode = require('../lib/pcode.js');
+var pcode = require('../../dsl/pcode'); // require('react/dsl/pcode');
 
 function falpha() { }
 function fbeta() { }
@@ -62,6 +62,20 @@ test('single task, single out params', function (t) {
   t.end();  
 });
 
+test('single task, single out params, cb(err)', function (t) {
+  var locals = { falpha: falpha };
+  var r = pcode('a, b', [
+    'c := falpha(a, b)',
+    'cb(err)'
+  ], locals);
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: 'falpha', a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();  
+});
+
 test('single task, err and out params', function (t) {
   var locals = { falpha: falpha };
   var r = pcode('a, b', [
@@ -319,3 +333,124 @@ test('selectFirst', function (t) {
   t.end();  
 });
 
+// full integration tests
+
+test('use pcodeDefine from module', function (t) {
+  t.plan(3);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.end();
+  });
+});
+
+test('use pcodeDefine with events', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].name, 'multiply', 'name matches');
+    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[1].name, 'add', 'name matches');
+    t.deepEqual(events[1].results, [8], 'results match');
+    t.end();
+  });
+});
+
+test('use pcodeDefine.selectFirst with events', function (t) {
+  t.plan(7);
+  function noSuccess(a, b, cb) {
+    setTimeout(function () { cb(null); }, 100); // returns undefined result
+  }
+  function noSuccessNull(a, b, cb) { cb(null, null); } // returns null result
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { noSuccess: noSuccess, noSuccessNull: noSuccessNull, add: add };
+  var fn = pcode.selectFirst('a, b, cb', [
+    'c := noSuccess(a, b)',
+    'c := noSuccessNull(a, b)',
+    'c := add(a, b)',
+    'c := noSuccess(a, b)',    
+    'cb(err, c)'
+  ], locals);
+
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, c) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(c, 5);
+    t.equal(events.length, 3, 'should have seen two 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.end();
+  });
+});
+
+test('use pcodeDefine events emit to global emitter', function (t) {
+  t.plan(8);
+  function multiply(a, b, cb) { cb(null, a * b); }
+  function add(a, b, cb) { cb(null, a + b); }
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  
+  var locals = { multiply: multiply, add: add };
+  var fn = pcode('a, b, cb', [
+    'm := multiply(a, b)',
+    's := add(m, a)',
+    'cb(err, m, s)'
+  ], locals);
+
+  pcode.events.on('task.complete', accumEvents);  // the global react emitter
+  
+  fn(2, 3, function (err, m, s) {
+    t.deepEqual(err, null, 'should not be any error');
+    t.equal(m, 6);
+    t.equal(s, 8);
+    t.equal(events.length, 2, 'should have seen two task compl events');
+    t.equal(events[0].name, 'multiply', 'name matches');
+    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[1].name, 'add', 'name matches');
+    t.deepEqual(events[1].results, [8], 'results match');
+    t.end();
+  });
+});
+