react 0.0.3 → 0.1.2

package/test/cb-task.test.js

@@ -0,0 +1,197 @@
+'use strict';
+
+var test = require('tap').test;
+
+var CbTask = require('../lib/cb-task.js');
+var VContext = require('../lib/vcon.js');
+
+function foo() { }
+function bar() { }
+function cat() { }
+
+test('new task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: []});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('ready task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'ready'});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('running task is not complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'running'});
+  t.equal(task.isComplete(), false);
+  t.end();
+});
+
+test('complete task is complete', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+  t.equal(task.isComplete(), true);
+  t.end();
+});
+
+test('task with any status is not ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'complete' });
+  var vCon = VContext.create([], []);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = 'ready';
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = 'running';
+  t.equal(task.isReady(vCon, tasksByName), false);
+  task.status = null;
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('no args defined, no after -> not ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b'], out: [] });
+  var vCon = VContext.create([], []);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  t.end();
+});
+
+test('objprop undefined -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+  var vCon = VContext.create([1, {}], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false);
+  t.end();  
+});
+
+test('all args defined, no after, out no obj parent -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d.e'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+  t.end();  
+});
+
+test('all args defined, no after, out no obj.par.par -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+  var vCon = VContext.create([1, { }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent undef');  
+  t.end();  
+});
+
+test('all args defined, no after, out null obj parent -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+  t.end();  
+});
+
+test('all args defined, no after, out null obj.par.par -> NOT ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['c.e.f'] });
+  var vCon = VContext.create([1, { e: null }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), false, 'false if out objparent null');  
+  t.end();  
+});
+
+test('all args defined, no after -> ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d'] });
+  var vCon = VContext.create([1, null], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('all args defined, objprop null, no after -> ready', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: ['b', 'c.prop'], out: [] });
+  var vCon = VContext.create([1, { prop: null }], ['b', 'c']);
+  var tasksByName = { foo: task };
+  t.equal(task.isReady(vCon, tasksByName), true);
+  t.end();  
+});
+
+test('all args defined, after not complete -> NOT ready', function (t) {
+  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'running' });
+  var task = new CbTask(
+    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+  var vCon = VContext.create([1, 2], ['b', 'c']);
+  var tasksByName = { foo: task, bar: tbar, cat: tcat };
+  t.equal(task.isReady(vCon, tasksByName), false);  
+  t.end();  
+});
+
+test('all args defined, after all complete -> ready', function (t) {
+  var tcat = new CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+  var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'complete' });
+  var task = new CbTask(
+    { type: 'cb', f: foo, a: ['b', 'c'], out: [], after: ['cat', 'bar']});
+  var vCon = VContext.create([1, 2], ['b', 'c']);
+  var tasksByName = { foo: task, bar: tbar, cat: tcat };
+  t.equal(task.isReady(vCon, tasksByName), true);  
+  t.end();  
+});
+
+test('string without . is not method call', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+  t.equal(task.isMethodCall(), false);
+  task.f = null;
+  t.equal(task.isMethodCall(), false);
+  t.end();
+});
+
+test('string with . is method call', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.bar', a: [], out: [] });
+  t.equal(task.isMethodCall(), true);
+  task.f = 'foo.bar.baz';
+  t.equal(task.isMethodCall(), true);
+  t.end();
+});
+
+test('undefined or null fn - functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+  var vCon = VContext.create([], []);
+  task.f = null;
+  t.notOk(task.functionExists(vCon));
+  task.f = undefined;
+  t.notOk(task.functionExists(vCon));
+  task.f = 'foo';
+  t.notOk(task.functionExists(vCon));
+  vCon.values.foo = { };
+  task.f = 'foo.bar';
+  t.notOk(task.functionExists(vCon));
+  t.end();
+});
+
+test('functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: foo, a: [], out: [] });
+  var vCon = VContext.create([], []);
+  t.ok(task.functionExists(vCon));
+  t.end();
+});
+
+test('method functionExists', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+  var vCon = VContext.create([{b: bar}], ['foo']);
+  t.ok(task.functionExists(vCon));
+  task.f = 'foo.bar.cat';
+  vCon.values.foo = { bar: { cat: cat}};
+  t.ok(task.functionExists(vCon));
+  t.end();
+});
+
+test('getMethodObj non-existent return undefined', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b.c', a: [], out: [] });
+  var vCon = VContext.create([{}], ['foo']);
+  t.equal(task.getMethodObj(vCon), undefined);
+  t.end();
+});
+
+test('getMethodObj returns object', function (t) {
+  var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+  var vCon = VContext.create([{b: bar}], ['foo']);
+  t.deepEqual(task.getMethodObj(vCon), { b: bar});
+  t.end();
+});
+

package/test/chain.test.js

@@ -0,0 +1,239 @@
+'use strict';
+
+var test = require('tap').test;
+var sprintf = require('sprintf').sprintf;
+
+var chainDefine = require('../lib/chain.js');
+
+function falpha() { }
+function fbeta() { }
+
+test('module exports a function', function (t) {
+  t.type(chainDefine, 'function', 'has define by chain method');
+  t.type(chainDefine(), 'object', 'has define by chain method');
+  t.type(chainDefine().selectFirst, 'function', 'has selectFirst def');
+  t.type(chainDefine().in, 'function', 'has input param def');
+  t.type(chainDefine().out, 'function', 'has output param def');
+  t.type(chainDefine().async, 'function', 'has async - cb type task def');
+  t.type(chainDefine().sync, 'function', 'has sync - ret type task def');
+  t.type(chainDefine().after, 'function', 'has after prereq def');
+  t.type(chainDefine().end, 'function', 'has end to complete flow and validate');
+  t.end();
+});
+
+test('no arguments -> empty inParams, tasks, outTask', function (t) {
+  var fn = chainDefine().end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('in only -> inParams["foo"], empty tasks, outTask', function (t) {
+  var fn = chainDefine()
+    .in('foo')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['foo']);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('in empty  -> inParams["foo"], empty tasks, outTask', function (t) {
+  var fn = chainDefine()
+    .in()
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('in triple first param -> inParams["foo", "bar", "baz"]', function (t) {
+  var fn = chainDefine()
+    .in('foo', 'bar', 'baz')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['foo', 'bar', 'baz']);
+  t.deepEqual(fn.ast.tasks, []);
+  t.deepEqual(fn.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('single task, single out params', function (t) {
+  var fn = chainDefine()
+    .out('c')
+    .async(falpha).in('a', 'b').out('c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('single task, err and out params', function (t) {
+  var fn = chainDefine()
+    .out('err', 'c')
+    .async(falpha).in('a', 'b').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('single task, ERR and out params', function (t) {
+  var fn = chainDefine()
+    .out('ERR', 'c')
+    .async(falpha).in('a', 'b').out('ERR', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, []);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('cb used in defs is simply ignored', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('callback used in defs is simply ignored', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'callback')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'callback').out('err', 'c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params, name, options', function (t) {
+  var fn = chainDefine()
+    .name('myflow')
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .options({ otherOptFoo: 'foo'})
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c').name('myalpha')
+    .async(fbeta).in('a', 'b', 'cb').out('err', 'd', 'e').options({ bar: 'bar'})
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'myalpha'},
+    { f: fbeta, type: 'cb', a: ['a', 'b'], out: ['d', 'e'],
+      bar: 'bar', name: 'fbeta' }
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.equal(fn.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(fn.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .sync(fbeta).in('a', 'b').out('d')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params, opts', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'd')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c').after(fbeta)
+    .sync(fbeta).in('a', 'b').out('d')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], after: ['fbeta'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['a', 'b'], out: ['d'], name: 'fbeta'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+// Object use
+test('object prop task params', function (t) {
+  var fn = chainDefine()
+    .in('a', 'b', 'cb')
+    .out('err', 'c', 'e')
+    .async(falpha).in('a', 'b.cat', 'cb').out('err', 'c')
+    .sync(fbeta).in('c.dog', 'b').out('d')
+    .async('d.egg').in('c').out('err', 'e')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b.cat'], out: ['c'], name: 'falpha'},
+    { f: fbeta, type: 'ret', a: ['c.dog', 'b'], out: ['d'], name: 'fbeta'},
+    { f: 'd.egg', type: 'cb', a: ['c'], out: ['e'], name: 'd.egg'}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
+  t.end();  
+});
+
+
+// selectFirst 
+
+test('selectFirst', function (t) {
+  var fn = chainDefine()
+    .selectFirst()
+    .in('a', 'b', 'cb')
+    .out('err', 'c')
+    .async(falpha).in('a', 'b', 'cb').out('err', 'c')
+    .sync(fbeta).in('a', 'b').out('c')
+    .end();
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+    { f: falpha, type: 'cb', a: ['a', 'b'], out: ['c'], name: 'falpha'},
+    { f: fbeta,  type: 'ret', a: ['a', 'b'], out: ['c'], name: 'fbeta', after: ['falpha']}
+  ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcbFirst' });
+  t.end();  
+});
+
+

package/test/core.test.js

@@ -0,0 +1,519 @@
+'use strict';
+
+var test = require('tap').test;
+
+var react = require('../react');
+
+function multiply(x, y, cb) { cb(null, x * y); }
+function add(x, y, cb) { cb(null, x + y); }
+function badFunc(a, b, cb) { throw new Error('badFuncThrow'); }
+function badF2(a, b, cb) { cb('my-error'); }
+function fnRetsSum(a, b) { return a + b; }
+
+test('set and validate AST', function (t) {
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    name: 'myflow',
+    inParams: ['a', 'b'],
+    tasks: [
+      { f: multiply, a: ['a', 'b'], out: ['c'] }
+    ],
+    outTask: { a: ['c'] },
+    otherOpt: 'foo',
+    otherOpt2: 'bar'
+  });
+  t.deepEqual(errors, [], 'should set and validate as true');
+  t.deepEqual(fn.ast.inParams, ['a', 'b']);
+  t.deepEqual(fn.ast.tasks, [
+      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'multiply' }
+    ]);
+  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.equal(fn.ast.name, 'myflow', 'name should match if set');
+  t.equal(fn.ast.otherOpt, 'foo', 'any additional options should pass through');
+  t.end();
+});
+
+test('unnamed tasks will be assigned unique names', function (t) {
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [
+      { f: multiply, a: ['a', 'b'], out: ['c'] },
+      { f: multiply, a: ['a', 'b'], out: ['d'], name: 'multiply' },
+      { f: multiply, a: ['a', 'b'], out: ['e'], name: 'times' },
+      { f: multiply, a: ['a', 'b'], out: ['f'] }
+    ],
+    outTask: { a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'should set and validate as true');
+  t.deepEqual(fn.ast.tasks, [
+      { f: multiply, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'multiply_0' },
+      { f: multiply, a: ['a', 'b'], out: ['d'], name: 'multiply', type: 'cb' },
+      { f: multiply, a: ['a', 'b'], out: ['e'], name: 'times', type: 'cb' },
+      { f: multiply, a: ['a', 'b'], out: ['f'], type: 'cb', name: 'multiply_3' }
+    ]);
+  t.end();
+});
+
+
+test('execution with no errors should call callback with result', function (t) {
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [
+      { f: multiply, a: ['a', 'b'], out: ['c'] }
+    ],
+    outTask: { a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+  fn(2, 3, function (err, c) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.end();
+  });
+});
+
+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'] },
+      { f: add, a: ['c', 'b'], out: ['d'] }
+    ],
+    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('multi-step with after as nonarr fn', function (t) {
+  t.plan(7);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'], after: add },
+      { f: add, a: ['a', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 5);
+    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.end();
+  });
+});  
+
+test('mixed multi-step with after as nonarr fn w/events', function (t) {
+  t.plan(19);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'], after: fnRetsSum },
+      { f: fnRetsSum, a: ['a', 'b'], out: ['d'], type: 'ret' }
+    ],
+    outTask: { a: ['c', 'd'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+  
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.equal(d, 5);
+    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.end();
+  });
+});  
+
+
+
+
+test('sets obj values', function (t) {
+  t.plan(5);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b', 'c'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
+      { f: fnRetsSum, a: ['c.mult', 'b'], out: ['c.sum'], type: 'ret' }
+    ],
+    outTask: { a: ['c.mult', 'c.sum', 'c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, { foo: 1 }, function (err, cmult, csum, c) {
+    t.deepEqual(err, null, 'should be no err');
+    t.equal(cmult, 6);
+    t.equal(csum, 9);
+    t.deepEqual(c, { foo: 1, mult: 6, sum: 9});
+    t.end();
+  });
+});  
+
+test('error when cant complete', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b', 'c'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c.mult'] },
+      { f: fnRetsSum, a: ['c.bad', 'b'], out: ['c.sum'], type: 'ret' }
+    ],
+    outTask: { a: ['c.mult', 'c.sum', 'c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, { foo: 1 }, function (err, cmult, csum, c) {
+    t.equal(err.message, 'no tasks running, flow will not complete');
+    t.end();
+  });
+});
+
+
+test('objects', function (t) {
+  function retObj(a, b, cb) { cb(null, { bar: a + b }); }
+  function concat(a, b, cb) { cb(null, { result: a + b }); }
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: retObj, a: ['a.foo', 'b'], out: ['c'] },
+      { f: concat, a: ['c.bar', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd.result'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn({ foo: 'FOO' }, 'B', function (err, c, dresult) {
+    t.equal(err, null);
+    t.deepEqual(c, { bar: 'FOOB' });
+    t.equal(dresult, 'FOOBB');
+    t.end();
+  });
+});  
+
+test('objects from container', function (t) {
+  var C = {
+    retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
+    concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
+  };
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: C.retObj, a: ['a.foo', 'b'], out: ['c'] },
+      { f: C.concat, a: ['c.bar', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd.result'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn({ foo: 'FOO' }, 'B', function (err, c, dresult) {
+    t.equal(err, null);
+    t.deepEqual(c, { bar: 'FOOB' });
+    t.equal(dresult, 'FOOBB');
+    t.end();
+  });
+});  
+
+test('objects from container input arg', function (t) {
+  var CONT = {
+    retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
+    concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
+  };
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b', 'CONT'],
+    tasks: [    
+      { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
+      { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd.result'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  
+  fn({ foo: 'FOO' }, 'B', CONT, function (err, c, dresult) {
+    t.equal(err, null);
+    t.deepEqual(c, { bar: 'FOOB' });
+    t.equal(dresult, 'FOOBB');
+    t.end();
+  });
+});  
+
+test('use locals for functions', function (t) {
+  var locals = {
+    retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
+    concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
+  };
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: 'retObj', a: ['a.foo', 'b'], out: ['c'] },
+      { f: 'concat', a: ['c.bar', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd.result'] },
+    locals: locals
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn({ foo: 'FOO' }, 'B', function (err, c, dresult) {
+    t.equal(err, null);
+    t.deepEqual(c, { bar: 'FOOB' });
+    t.equal(dresult, 'FOOBB');
+    t.end();
+  });
+});  
+
+test('objects from locals', function (t) {
+  var CONT = {
+    retObj: function retObj(a, b, cb) { cb(null, { bar: a + b }); },
+    concat: function concat(a, b, cb) { cb(null, { result: a + b }); }
+  };
+  t.plan(4);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: 'CONT.retObj', a: ['a.foo', 'b'], out: ['c'] },
+      { f: 'CONT.concat', a: ['c.bar', 'b'], out: ['d'] }
+    ],
+    outTask: { a: ['c', 'd.result'] },
+    locals: { CONT: CONT }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  
+  fn({ foo: 'FOO' }, 'B', function (err, c, dresult) {
+    t.equal(err, null);
+    t.deepEqual(c, { bar: 'FOOB' });
+    t.equal(dresult, 'FOOBB');
+    t.end();
+  });
+});  
+  
+test('multi-step func throws, cb with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'] },
+      { f: badFunc, a: ['c', 'b'], out: ['d'] }
+    ],
+    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('multi-step func cb err, cb with error', function (t) {
+  t.plan(2);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'] },
+      { f: badF2, a: ['c', 'b'], out: ['d'] },
+      { f: add, a: ['d', 'b'], out: ['e'] }
+    ],
+    outTask: { a: ['c', 'e'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err.message, 'my-error');
+    t.end();
+  });
+});  
+  
+
+test('selectFirst with first succeeding', function (t) {
+  t.plan(6);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: multiply, a: ['a', 'b'], out: ['c'] },
+      { f: add, a: ['a', 'b'], out: ['c'], after: ['multiply'] }
+    ],
+    outTask: { type: 'finalcbFirst', a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    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.end();
+  });
+});  
+
+test('selectFirst with third succeeding', function (t) {
+  function noSuccess(a, b, cb) { cb(null); } // returns undefined result
+  function noSuccessNull(a, b, cb) { cb(null, null); } // returns null result
+  
+  t.plan(6);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: noSuccess, a: ['a', 'b'], out: ['c'] },
+      { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess'] },
+      { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] }
+    ],
+    outTask: { type: 'finalcbFirst', a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 5);
+    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.end();
+  });
+});  
+
+
+test('selectFirst forces order with third succeeding', function (t) {
+  function noSuccess(a, b, cb) {
+    setTimeout(function () { cb(null); }, 100); // returns undefined result
+  }
+  function noSuccessNull(a, b, cb) { cb(null, null); } // returns null result
+  
+  t.plan(8);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: noSuccess, a: ['a', 'b'], out: ['c'] },
+      { f: noSuccessNull, a: ['a', 'b'], out: ['c'], after: ['noSuccess']},
+      { f: add, a: ['a', 'b'], out: ['c'], after: ['noSuccessNull'] },
+      { f: noSuccess, a: ['a', 'b'], out: ['c'], after: ['add'] }
+    ],
+    outTask: { type: 'finalcbFirst', a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 5);
+    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.end();
+  });
+});  
+
+
+
+
+test('selectFirst using direct returns', function (t) {
+  function noSuccess(a, b) {  } // returns undefined result
+  function noSuccessNull(a, b) { return null; } // returns null result
+  function addRet(a, b) { return a + b; }
+  
+  t.plan(6);
+  var fn = react();
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [    
+      { f: noSuccess, a: ['a', 'b'], out: ['c'], type: 'ret' },
+      { f: noSuccessNull, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccess'] },
+      { f: addRet, a: ['a', 'b'], out: ['c'], type: 'ret', after: ['noSuccessNull'] }
+    ],
+    outTask: { type: 'finalcbFirst', a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+
+  var events = [];
+  function accumEvents(task) {
+    events.push(task);
+  }
+  fn.events.on('task.complete', accumEvents);
+
+  fn(2, 3, function (err, c, d) {
+    t.equal(err, null);
+    t.equal(c, 5);
+    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.end();
+  });
+});  
+
+