react 0.0.2 → 0.2.1

package/test/dsl.test.js

@@ -0,0 +1,237 @@
+'use strict';
+
+var test = require('tap').test;
+var sprintf = require('sprintf').sprintf;
+
+var react = require('../'); // require('react');
+
+function falpha() { }
+function fbeta() { }
+
+test('module exports is a fn with properties', function (t) {
+  t.type(react, 'function', 'has define by DSL method'); //
+  t.type(react.selectFirst, 'function', 'has selectFirst define method');
+  t.end();
+});
+
+test('no arguments -> empty name, inParams, tasks, outTask', function (t) {
+  var r = react();
+  t.equal(r.ast.name, undefined);
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('empty first string -> empty name, inParams, tasks, outTask', function (t) {
+  var r = react('');
+  t.equal(r.ast.name, '');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('single first string -> name, inParams["foo"], empty tasks, outTask', function (t) {
+  var r = react('foo');
+  t.equal(r.ast.name, 'foo');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask',
+     function (t) {
+  var r = react('myName', ' foo,   bar,baz  ');
+  t.equal(r.ast.name, 'myName');
+  t.deepEqual(r.ast.inParams, ['foo', 'bar', 'baz']);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('single task, single out params', function (t) {
+  var r = react('myName', 'cb -> err, c',
+    falpha, 'a, b, cb -> err, c'
+  );
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], 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, 'a, b, cb -> err, c'
+  );
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], 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, 'a, b, cb -> ERR, c'
+  );
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('cb used in defs is simply ignored', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c', 
+    falpha, 'a, b, cb -> err, c'
+  );
+  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: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('callback used in defs is simply ignored', function (t) {
+  var r = react('myName', 'a, b, callback -> err, c',
+    falpha, 'a, b, callback -> err, c'
+  );
+  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: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c, d',
+    falpha, 'a, b, cb -> err, c',
+    fbeta,  'a, b, cb -> err, d, e'
+  );
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params, options', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c, d',
+    { otherOptFoo: 'foo'},  // main flow options
+    falpha, 'a, b, cb -> err, c',
+    fbeta,  'a, b, cb -> err, d, e'
+  );
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.equal(r.ast.name, 'myName', 'name should match');
+  t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c, d',
+    falpha, 'a, b, cb -> err, c',
+    fbeta,  'a, b -> d'
+  );
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+
+test('two inputs, two mixed tasks, two out params, opts', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c, d', 
+    falpha, 'a, cb -> err, c', { after: fbeta },
+    fbeta,  'a, b -> d'
+  );
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { after: ['fbeta'], f: falpha, a: ['a'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+
+// Object use
+test('object prop task params', function (t) {
+  var r = react('myName', 'a, b, cb -> err, c, e', 
+    falpha, 'a, b.cat, cb -> err, c',
+    fbeta,  'c.dog, b -> d',
+    'd.egg', 'c, cb -> err, e'
+  );
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b.cat'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['c.dog', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
+    { f: 'd.egg', a: ['c'], out: ['e'], type: 'cb', name: 'd.egg'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
+  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 },
+      fbeta,  'a, b -> returns d',
+      'extraBadArg'
+    );
+  };
+  t.throws(fn, new Error('extra unmatched task arg: extraBadArg'));
+  t.end();  
+});
+
+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 },
+      fbeta
+    );
+  };
+  t.throws(fn, new Error(sprintf('extra unmatched task arg: %s', fbeta)));
+  t.end();  
+});
+
+
+
+// selectFirst 
+
+test('selectFirst', function (t) {
+  var r = react.selectFirst('myName', 'a, b, cb -> c',
+    { otherOptFoo: 'foo'},  // main options                            
+    falpha, 'a, b, cb -> err, c',
+    fbeta,  'a, b -> c'
+  );
+  t.equal(r.ast.name, 'myName');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['c'], type: 'ret', name: 'fbeta', after: ['falpha']}
+  ]);
+  t.deepEqual(r.ast.outTask, { type: 'finalcbFirst', a: ['c'] });
+  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/event-manager.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var test = require('tap').test;
+
+var EventManager = require('../lib/event-manager.js');
+
+test('Event Manager is disabled by default', function (t) {
+  var em = EventManager.create();
+  t.notOk(em.isEnabled(), 'should be falsey by default');
+  t.end();
+});
+
+test('Event Manager enabled when a listener if registered', function (t) {
+  var em = EventManager.create();
+  em.on('foo', function () { });
+  t.ok(em.isEnabled(), 'should be truthy');
+  t.end();
+});
+
+test('Event Manager emits events', function (t) {
+  t.plan(1);
+  var em = EventManager.create();
+  em.on('foo', function (data) {
+    t.equal(data, 'hello');
+    t.end();
+  });
+  em.emit('foo', 'hello');
+});
+
+test('Event Manager emits events, wildcarded listener', function (t) {
+  t.plan(1);
+  var em = EventManager.create();
+  em.on('foo.*', function (data) {
+    t.equal(data, 'hello-world');
+    t.end();
+  });
+  em.emit('foo.bar', 'hello-world');
+});
+
+test('Event Manager emits events, all wildcarded listener', function (t) {
+  t.plan(1);
+  var em = EventManager.create();
+  em.on('*', function (data) {
+    t.equal(data, 'hello-world');
+    t.end();
+  });
+  em.emit('foo.bar', 'hello-world');
+});
+
+test('Event Manager emits event with three args', function (t) {
+  t.plan(3);
+  var em = EventManager.create();
+  em.on('foo', function (data, data2, data3) {
+    t.equal(data, 'hello');
+    t.equal(data2, 'world');
+    t.equal(data3, 100);
+    t.end();
+  });
+  em.emit('foo', 'hello', 'world', 100);
+});
+
+test('Event Manager with a parentListener will receive events', function (t) {
+  t.plan(1);
+  var parentEm = EventManager.create();
+  var em = EventManager.create();
+  em.parent = parentEm;
+  parentEm.on('foo', function (data) {
+    t.equal(data, 'world');
+    t.end();
+  });
+  em.emit('foo', 'world');
+});
+
+test('Event Manager w/listening grandparent will receive events', function (t) {
+  t.plan(1);
+  var grandEm = EventManager.create();
+  var parentEm = EventManager.create();
+  parentEm.parent = grandEm;
+  var em = EventManager.create();
+  em.parent = parentEm;
+  grandEm.on('foo', function (data) {
+    t.equal(data, 'world');
+    t.end();
+  });
+  em.emit('foo', 'world');
+});
+
+test('Event Manager all parents w/listeners will receive events', function (t) {
+  t.plan(3);
+  var grandEm = EventManager.create();
+  var parentEm = EventManager.create();
+  parentEm.parent = grandEm;
+  var em = EventManager.create();
+  em.parent = parentEm;
+  function recData(data) {
+    t.equal(data, 'hello');
+  }
+  grandEm.on('bar', recData);
+  parentEm.on('bar', recData);
+  em.on('bar', recData);
+  em.emit('bar', 'hello');
+});

package/test/exec-options.test.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var test = require('tap').test;
+
+var react = require('../react');
+
+function multiply(x, y, cb) { cb(null, x * y); }
+
+test('execOptions as first param', function (t) {
+  t.plan(3);
+  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');
+
+  var execOptions = {
+    reactExecOptions: true,
+    outputStyle: 'callback'
+  };
+  
+  fn(execOptions, 2, 3, function (err, c) {
+    t.equal(err, null);
+    t.equal(c, 6);
+    t.end();
+  });
+});  
+

package/test/finalcb-task.test.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var test = require('tap').test;
+
+var FinalCbTask = require('../lib/finalcb-task.js');
+
+test('undefined cb throws exception', function (t) {
+  var fn = function () {
+    var finalTask = FinalCbTask.create({}, undefined);
+  };
+  t.throws(fn, new Error('callback is not a function'));
+  t.end();
+});
+
+test('null cb  throws exception', function (t) {
+  var fn = function () {
+    var finalTask = FinalCbTask.create({}, null);
+  };
+  t.throws(fn, new Error('callback is not a function'));
+  t.end();
+});
+
+test('cb needs to be a function or throws exception', function (t) {
+  var fn = function () {
+    var finalTask = FinalCbTask.create({}, 'foo');
+  };
+  t.throws(fn, new Error('callback is not a function'));
+  t.end();
+});
+
+test('valid fn creates outTask', function (t) {
+  function foo() { }
+  var finalTask = FinalCbTask.create({ a: ['bar', 'baz']}, foo);
+  t.equal(finalTask.f, foo);
+  t.deepEqual(finalTask.a, ['bar', 'baz']);
+  t.end();
+});

package/test/fstr.test.js

@@ -0,0 +1,288 @@
+'use strict';
+
+var test = require('tap').test;
+var sprintf = require('sprintf').sprintf;
+
+var fstrDefine = require('../lib/fstr.js');
+
+function falpha() { }
+function fbeta() { }
+
+test('module exports an object', function (t) {
+  t.type(fstrDefine, 'function', 'has define by DSL method');
+  t.end();
+});
+
+test('no arguments -> empty inParams, tasks, outTask', function (t) {
+  var r = fstrDefine();
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('empty first string -> empty inParams, tasks, outTask', function (t) {
+  var r = fstrDefine('');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+
+test('single first string -> inParams["foo"], empty tasks, outTask', function (t) {
+  var r = fstrDefine('foo');
+  t.deepEqual(r.ast.inParams, ['foo']);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('triple first string -> inParams["foo", "bar", "baz"], empty tasks, outTask',
+     function (t) {
+  var r = fstrDefine(' foo,   bar,baz  ');
+  t.deepEqual(r.ast.inParams, ['foo', 'bar', 'baz']);
+  t.deepEqual(r.ast.tasks, []);
+  t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+  t.end();
+});
+
+test('single task, single out params', function (t) {
+  var r = fstrDefine('', [
+    falpha, 'a, b -> err, c'
+  ], 'c');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], 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 = fstrDefine('', [
+    falpha, 'a, b -> err, c'
+  ], 'err, c');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], 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 = fstrDefine('', [
+    falpha, 'a, b -> ERR, c'
+  ], 'ERR, c');
+  t.deepEqual(r.ast.inParams, []);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('cb used in defs is simply ignored', function (t) {
+  var r = fstrDefine('a, b, cb', [
+    falpha, 'a, b, cb -> err, c'
+  ], 'err, c');
+  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: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('callback used in defs is simply ignored', function (t) {
+  var r = fstrDefine('a, b, callback', [
+    falpha, 'a, b, callback -> err, c'
+  ], 'err, c');
+  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: ['c'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> err, d, e'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two tasks, two out params, options', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> err, d, e'
+  ], 'c, d', { name: 'myflow', otherOptFoo: 'foo'});
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d', 'e'], type: 'cb', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.equal(r.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> returns d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('uses return', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> return d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('uses Return', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> Return d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('uses RETURN', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> RETURN d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('uses RETURNS', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> RETURNS d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+test('two inputs, two mixed tasks, two out params, opts', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a -> err, c', { after: fbeta },
+    fbeta,  'a, b -> returns d'
+  ], 'c, d');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { after: ['fbeta'], f: falpha, a: ['a'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['d'], type: 'ret', name: 'fbeta'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' });
+  t.end();  
+});
+
+
+// Object use
+test('object prop task params', function (t) {
+  var r = fstrDefine('a, b', [
+    falpha, 'a, b.cat -> err, c',
+    fbeta,  'c.dog, b -> returns d',
+    'd.egg', 'c -> e'
+  ], 'c, e');
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b.cat'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['c.dog', 'b'], out: ['d'], type: 'ret', name: 'fbeta'},
+    { f: 'd.egg', a: ['c'], out: ['e'], type: 'cb', name: 'd.egg'}
+  ]);
+  t.deepEqual(r.ast.outTask, { a: ['c', 'e'], type: 'finalcb' });
+  t.end();  
+});
+
+
+
+
+
+test('extra arg throws error', function (t) {
+  var fn = function () {
+    var r = fstrDefine('a, b', [
+      falpha, 'a -> err, c', { after: fbeta },
+      fbeta,  'a, b -> returns d',
+      'extraBadArg'
+    ], 'c, d');
+  };
+  t.throws(fn, new Error('extra unmatched task arg: extraBadArg'));
+  t.end();  
+});
+
+test('not enough args throws error', function (t) {
+  var fn = function () {
+    var r = fstrDefine('a, b', [
+      falpha, 'a -> err, c', { after: fbeta },
+      fbeta
+    ], 'c, d');
+  };
+  t.throws(fn, new Error(sprintf('extra unmatched task arg: %s', fbeta)));
+  t.end();  
+});
+
+
+
+/* selectFirst */
+
+test('selectFirst', function (t) {
+  var r = fstrDefine.selectFirst('a, b', [
+    falpha, 'a, b -> err, c',
+    fbeta,  'a, b -> returns c'
+  ], 'c', { name: 'myflow', otherOptFoo: 'foo'});
+  t.deepEqual(r.ast.inParams, ['a', 'b']);
+  t.deepEqual(r.ast.tasks, [
+    { f: falpha, a: ['a', 'b'], out: ['c'], type: 'cb', name: 'falpha'},
+    { f: fbeta,  a: ['a', 'b'], out: ['c'], type: 'ret', name: 'fbeta', after: ['falpha']}
+  ]);
+  t.deepEqual(r.ast.outTask, { type: 'finalcbFirst', a: ['c'] });
+  t.equal(r.ast.name, 'myflow', 'name should match if supplied');
+  t.equal(r.ast.otherOptFoo, 'foo', 'other options should pass through');
+  t.end();  
+});
+