react 0.3.5 → 0.6.0

package/test/dsl.test.js

@@ -1,330 +0,0 @@
-'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, 'cb -> err, c'
-  );
-  t.deepEqual(r.ast.inParams, []);
-  t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: [], 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'
-  );
-  t.deepEqual(r.ast.inParams, []);
-  t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: [], out: ['c'], type: 'cb', name: 'falpha'}
-  ]);
-  t.deepEqual(r.ast.outTask, { a: ['c'], type: 'finalcb' });
-  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'
-  );
-  t.deepEqual(r.ast.inParams, []);
-  t.deepEqual(r.ast.tasks, [
-    { f: falpha, a: [], 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();  
-});
-
-// 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, cb -> 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 -> err, c, d', 
-      falpha, 'a, cb -> err, c', { after: fbeta },
-      fbeta
-    );
-  };
-  t.throws(fn, new Error(sprintf('extra unmatched task arg: %s', fbeta)));
-  t.end();  
-});
-
-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); }
-  function markdown(filedata) { return 'html'+filedata; }
-  function prepareDirectory(outDirname, cb){ setTimeout(cb, 200, null, 'dircreated-'+outDirname); }
-  function writeOutput(html, user, cb){  setTimeout(cb, 300, null, html+'_bytesWritten'); }
-  function loadEmailTemplate(cb) { setTimeout(cb, 50, null, 'emailmd'); }
-  function customizeEmail(user, emailHtml) { return 'cust-'+user+emailHtml; }
-  function deliverEmail(custEmailHtml, cb) { setTimeout(cb, 100, null, 'delivered-'+custEmailHtml); }
-  var loadAndSave = react('loadAndSave', 'filename, uid, outDirname, cb -> err, html, user, bytesWritten',  // name, in/out params
-    loadUser,         'uid, cb          -> err, user',     // calling async fn loadUser with uid, callback is called with err and user
-    loadFile,         'filename, cb     -> err, filedata',
-    markdown,         'filedata         -> html',    // using a sync function
-    prepareDirectory, 'outDirname, cb   -> err, dircreated',
-    writeOutput,      'html, user, cb   -> err, bytesWritten', { after: prepareDirectory },  // only after prepareDirectory done
-    loadEmailTemplate, 'cb              -> err, emailmd',
-    markdown,         'emailmd          -> emailHtml',   // using a sync function
-    customizeEmail,   'user, emailHtml  -> custEmailHtml',
-    deliverEmail,     'custEmailHtml, cb -> err, deliveredEmail', { after: writeOutput }  // only after writeOutput is done
-  );
-  loadAndSave('file.md', 100, '/tmp/foo', function (err, html, user, bytesWritten) {  // executing the flow
-    t.equal(err, null);
-    t.equal(html, 'htmlFiledatafile.md');
-    t.equal(user, 'User100');
-    t.equal(bytesWritten, 'htmlFiledatafile.md_bytesWritten');
-    t.end();
-  });
-});
-
-// selectFirst 
-
-test('selectFirst', function (t) {
-  var r = react.selectFirst('myName', 'a, b, cb -> err, 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/dsl/chain.test.js

@@ -1,324 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-var sprintf = require('sprintf').sprintf;
-
-var chainDefine = require('../../dsl/chain'); // require('react/dsl/chain');
-require('../../lib/track-tasks');  // require('react/lib/track-tasks'); // turn on tracking
-
-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()
-    .in('a', 'b')
-    .out('c')
-    .async(falpha).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' }
-  ]);
-  t.deepEqual(fn.ast.outTask, { a: ['c'], type: 'finalcb' });
-  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')
-    .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: ['c'], type: 'finalcb' });
-  t.end();  
-});
-
-test('single task, ERR and out params', function (t) {
-  var fn = chainDefine()
-    .out('ERR', 'c')
-    .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: ['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();  
-});
-
-
-// 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();
-  });
-});