react 0.3.0 → 0.5.1

package/lib/finalcb-task.js

@@ -4,23 +4,23 @@ var sprintf = require('sprintf').sprintf;
 var util = require('util');
 
 var STATUS = require('./status.js');
+var EventManager = require('./event-manager.js');
 
 var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
 function FinalCbTask(outTaskOptions) {
   var taskDef = outTaskOptions.taskDef;
-  var cbFunc = outTaskOptions.cbFunc;
-  var tasks = outTaskOptions.tasks;
-  var vCon = outTaskOptions.vCon;
-  var execOptions = outTaskOptions.execOptions;
-  var retValue = outTaskOptions.retValue;
-  if (typeof(cbFunc) !== 'function') throw new Error('callback is not a function'); 
+  if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
   var self = this;
-  Object.keys(taskDef).forEach(function (k) { self[k] = taskDef[k]; });
-  this.f = cbFunc;
-  this.tasks = tasks;
-  this.vCon = vCon;
-  this.retValue = retValue;
+  for (var k in taskDef) {
+    if (true) self[k] = taskDef[k];  // if to make jshint happy
+  }
+  this.f = outTaskOptions.cbFunc;
+  this.tasks = outTaskOptions.tasks;
+  this.vCon = outTaskOptions.vCon;
+  this.retValue = outTaskOptions.retValue;
+  this.execOptions = outTaskOptions.execOptions;
+  this.env = outTaskOptions.env;
 }
 
 function format_error(errmsg, obj) {
@@ -44,11 +44,15 @@ FinalCbTask.prototype.isReady = function () {
 FinalCbTask.prototype.exec = function (err) {
   if (!this.f) return;   //must have already been called
   if (err) {
+    this.env.error = err;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_ERRORED, this.env);
     this.f.call(null, err); //call the final callback with the first error hit
   } else { // no error, call with args
     var vCon = this.vCon;
     var finalArgs = this.a.map(function (k) { return vCon.getVar(k); });
     finalArgs.unshift(null);   //unshift err=null to front
+    this.env.results = finalArgs;
+    this.env.flowEmitter.emit(EventManager.TYPES.EXEC_FLOW_COMPLETE, this.env);
     this.f.apply(null, finalArgs);
   }
   this.f = null;   // prevent multiple calls

package/lib/id.js

@@ -4,6 +4,7 @@ var startingId = 0;
 
 function createUniqueId() {
   startingId += 1;
+  if (startingId === Number.MAX_VALUE) startingId = 0; // if hits this start over //TODO need something better?
   return startingId;
 }
 

package/lib/log-events.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+   Log events to console.error
+
+   @example
+   var react = require('react');
+   react.logEvents(); // log all task and flow events on all react functions
+   react.logEvents('task.*'); // log all task events on all react functions
+   react.logEvents(flowFn); // log all task and flow events on flowFn only
+   react.logEvents(flowFn, 'flow.*'); // log all flow events on flowFn only
+  */
+
+var util = require('util'); // TODO replace inspect with something portable to browser
+
+var react = require('../'); // require('react');
+react.trackTasks(); // enable task and flow tracking
+
+var ALL_FLOW_EVENTS = 'flow.*';
+var ALL_TASK_EVENTS = 'task.*';
+var FLOW_RE = /^flow\./;
+
+function flowLog(obj) {
+  /*jshint validthis: true */
+  var time = new Date();
+  time.setTime(obj.time);
+  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
+  var eventTimeStr = time.toISOString();
+  if (this.event === 'flow.complete') {
+    var env = obj; 
+    console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
+                  this.event, env.name, env.elapsedTime, util.inspect(argsNoCb), util.inspect(env.results));   
+  } else {
+    var name = obj.name;
+    var args = obj.args;
+    console.error('%s: %s \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
+  }    
+}
+
+function taskLog(obj) {
+  /*jshint validthis: true */
+  var time = new Date();
+  time.setTime(obj.time);
+  var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
+  var eventTimeStr = time.toISOString();
+  if (this.event === 'task.complete') {
+    var task = obj;
+    console.error('%s: %s:%s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
+                  this.event, task.env.name, task.name, task.elapsedTime, util.inspect(argsNoCb), util.inspect(task.results));
+  } else {
+    var name = obj.name;
+    var args = obj.args;
+    console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.name, util.inspect(argsNoCb));
+  }
+  
+}
+
+/**
+   Log flow and task events for a flowFn or all of react.
+   If called multiple times, remove previous listener (if any) before
+   adding.
+   
+   @example
+   var react = require('react');
+   react.logEvents(flowFn, eventWildcard); //log events on flowfn matching wildcard
+   
+   @param flowFn Flow function or global react object
+   @param eventWildcard wildcarded event type, if not provided use flow.* and task.*
+  */
+function logEvents(flowFn, eventWildcard) {
+  if (!flowFn) flowFn = react; // use global 
+  if (eventWildcard && eventWildcard !== '*') {
+    var logFn = (FLOW_RE.test(eventWildcard)) ? flowLog : taskLog;
+    flowFn.events.removeListener(eventWildcard, logFn);
+    flowFn.events.on(eventWildcard, logFn);
+  } else { // none provided, use flow.* and task.*
+    //output events as tasks start and complete
+    flowFn.events.removeListener(ALL_FLOW_EVENTS, flowLog);
+    flowFn.events.on(ALL_FLOW_EVENTS, flowLog);
+    flowFn.events.removeListener(ALL_TASK_EVENTS, taskLog);
+    flowFn.events.on(ALL_TASK_EVENTS, taskLog);      
+  }
+}
+
+module.exports = react;
+module.exports.logEvents = logEvents;

package/{promise-resolve.js → lib/promise-resolve.js}

@@ -10,13 +10,13 @@
   */
 
 
-var react = require('./');  // require('react');
+var react = require('../');  // require('react');
 
 var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
 
-react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (taskEnv) {
-  var vConValues = taskEnv.vCon.values;
-  var promiseParams = taskEnv.ast.inParams.filter(function (p) {
+react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (env) {
+  var vConValues = env.vCon.values;
+  var promiseParams = env.ast.inParams.filter(function (p) {
     var value = vConValues[p];
     return (value && typeof(value.then) === 'function');
   });
@@ -24,7 +24,7 @@ react.events.on(react.events.TYPES.EXEC_TASKS_PRECREATE, function (taskEnv) {
     var promiseName = p + PROMISE_SUFFIX;
     vConValues[promiseName] = vConValues[p];
     vConValues[p] = undefined;
-    taskEnv.taskDefs.push({
+    env.taskDefs.push({
       type: 'when',
       a: [promiseName],
       out: [p]

package/lib/task.js

@@ -20,6 +20,9 @@ var TASK_TYPES = {
   promise: PromiseTask,
   when: WhenTask
 };
+
+var DEFAULT_TASK_NAME = 'task_%s';  // for unnamed tasks use task_idx, like task_0
+
 function taskTypeKeys() { return Object.keys(TASK_TYPES); }
 
 var OUT_TASK_TYPES = {
@@ -127,9 +130,10 @@ function validateLocalFunctions(inParams, taskDefs, locals) {
 }
 
 function fName(fn) {
-  return (fn) ?
-    ((fn.name) ? fn.name : fn) :  // if defined, try name, otherwise toString()
-    'undefined';  // not defined, use undefined
+  if (typeof(fn) === 'function') {
+    return fn.name;
+  }
+  return (fn) ? fn : '';
 }
 
 /**
@@ -148,6 +152,7 @@ function nameTasks(tasks) { //name tasks that are not already named, validation
   tasks.forEach(function (t, idx) {
     if (!t.name) { //not already named
       var name = fName(t.f);
+      if (!name) name = sprintf(DEFAULT_TASK_NAME, idx);
       if (!name || namesMap[name]) {
         name = sprintf('%s_%s', name, idx); //if empty or already used, postfix with _idx
       }
@@ -163,7 +168,7 @@ function create(taskDef) {
   return new TaskConstructor(taskDef);
 }
 
-function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions) {
+function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions, env) {
   setMissingOutTaskType(taskDef);
   var outTaskOptions = {
     taskDef: taskDef,
@@ -171,6 +176,7 @@ function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions) {
     tasks: tasks,
     vCon: vCon,
     execOptions: execOptions,
+    env: env,
     TaskConstructor: OUT_TASK_TYPES[taskDef.type]
   };
   EventManager.global.emit(EventManager.TYPES.EXEC_OUTTASK_CREATE, outTaskOptions); // hook
@@ -181,6 +187,9 @@ function createOutTask(taskDef, cbFunc, tasks, vCon, execOptions) {
 function createErrorHandler(vCon, outTask) {
   return function handleError(task, err) {
     task.status = STATUS.ERRORED;
+    task.error = err;
+    outTask.env.currentTask = task;
+    outTask.env.flowEmitter.emit(EventManager.TYPES.EXEC_TASK_ERRORED, task);
     var errWithMeta = error.augmentError(err, {task: task, vcon: vCon});
     outTask.exec(errWithMeta); //call the final callback with the first error hit
   };
@@ -202,7 +211,7 @@ function execTasks(tasksReady, vCon, handleError, contExec) {
    case everything is fine. If no tasks are running then
    call handleError since this will never complete.
   */
-function checkIfTasksRunning(vCon, tasks, handleError) {
+function checkIfTasksRunning(vCon, tasks, handleError, env) {
   var tasksRunning = tasks.filter(function (t) {
     return (t.status === STATUS.RUNNING || t.status === STATUS.READY);
   });
@@ -210,13 +219,14 @@ function checkIfTasksRunning(vCon, tasks, handleError) {
     var remainingTasks = tasks.filter(function (t) { return (!t.status); });
     var remainingTNames = remainingTasks.map(function (t) { return t.name; });
     var errMsg = sprintf(NO_TASKS_RUNNING_WONT_COMPLETE, remainingTNames.join(', '));
-    handleError({}, new Error(errMsg));
+    var emptyTask = { env: env };
+    handleError(emptyTask, new Error(errMsg));
   }
 }
 
-function findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec) {
+function findReadyAndExec(vCon, tasks, tasksByName, handleError, contExec, env) {
   var tasksReady = findTasksReady(vCon, tasks, tasksByName);
-  if (!tasksReady.length) checkIfTasksRunning(vCon, tasks, handleError); // no tasks to run, check if ok
+  if (!tasksReady.length) checkIfTasksRunning(vCon, tasks, handleError, env); // no tasks to run, check if ok
   execTasks(tasksReady, vCon, handleError, contExec);
 }
 

package/lib/track-tasks.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+   Track the tasks, start, complete, args, results, elapsed time
+   Emits events that can be monitored
+
+    - track start and complete
+    - record args each task was called with
+    - record results at completion
+    - record start, end, and calc elapsed time
+    - emits flow.begin with flowEnv
+    - emits task.begin with task
+    - emits task.complete with task
+    - emits flow complete with flowEnv
+    - emits flow errored with flowEnv
+
+    @example
+    var react = require('react');
+    react.trackTasks(); // enable task and flow tracking
+  */
+
+
+var react = require('../');  // require('react');
+
+react.events.on(react.events.TYPES.EXEC_FLOW_START, function (env){
+  env.startTime = Date.now();
+  env.flowEmitter.emit(react.events.TYPES.FLOW_BEGIN, env); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_START, function (task) {
+  task.startTime = Date.now();
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_BEGIN, task); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_COMPLETE, function (task) {
+  task.endTime = Date.now();
+  task.elapsedTime = task.endTime - task.startTime;
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_COMPLETE, task); // fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_TASK_ERRORED, function (task) {
+  task.endTime = Date.now();
+  task.elapsedTime = task.endTime - task.startTime;
+  task.env.flowEmitter.emit(react.events.TYPES.TASK_ERRORED, task); // fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_FLOW_COMPLETE, function (env) {
+  env.endTime = Date.now();
+  env.elapsedTime = env.endTime - env.startTime;
+  env.flowEmitter.emit(react.events.TYPES.FLOW_COMPLETE, env); //fire public ev
+});
+
+react.events.on(react.events.TYPES.EXEC_FLOW_ERRORED, function (env) {
+  env.endTime = Date.now();
+  env.elapsedTime = env.endTime - env.startTime;
+  env.flowEmitter.emit(react.events.TYPES.FLOW_ERRORED, env); //fire public ev
+});
+
+
+module.exports = react;  // return react

package/lib/vcon.js

@@ -71,7 +71,7 @@ VContext.create = function (args, inParams, locals, self) {
   var vContext = new VContext();
   vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
     var param = inParams[idx];
-    if (param) vcon[param] = x;
+    if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
     return vcon;
   }, initValues);
   return vContext;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react",
-  "description": "React is a javascript module to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
-  "version": "0.3.0",
+  "description": "React is a javascript module implementing a lightweight rules engine to make it easier to work with asynchronous code, by reducing boilerplate code and improving error and exception handling while allowing variable and task dependencies when defining flow.",
+  "version": "0.5.1",
   "author": "Jeff Barczewski <jeff.barczewski@gmail.com>",
   "repository": { "type": "git", "url": "http://github.com/jeffbski/react.git" },
   "bugs" : { "url": "http://github.com/jeffbski/react/issues" },

package/react.js

@@ -2,7 +2,39 @@
 
 var core = require('./lib/core.js');
 
+/**
+   If called, load the built-in plugin for log events and invoke
+
+   @param flowFn [function] if not provided uses global react
+   @param eventWildcard [string] pattern to log events for
+  */
+function logEvents(flowFn, eventWildcard) {
+  var logEventsMod = require('./lib/log-events');
+  if (!eventWildcard && typeof(flowFn) === 'string') { // only wildcard provided
+    eventWildcard = flowFn;
+    flowFn = undefined;
+  } 
+  return logEventsMod.logEvents(flowFn, eventWildcard);
+}
+
+/**
+   Enable detection of promises and resolution
+  */
+function resolvePromises() {
+  require('./lib/promise-resolve');
+}
+
+/**
+   Enable tracking of tasks and flow execution, emitting events and
+   tracking start, end, elapsed time
+  */
+function trackTasks() {
+  require('./lib/track-tasks');
+}
+
 module.exports = require('./lib/dsl.js');  // core + default dsl
 module.exports.options = core.options; // global react options
 module.exports.events = core.events;   // global react event emitter
-
+module.exports.logEvents = logEvents;  // enable event logging
+module.exports.resolvePromises = resolvePromises; // enable promise resolution
+module.exports.trackTasks = trackTasks; // enable tracking of tasks

package/test/ast.test.js

@@ -2,7 +2,8 @@
 
 var test = require('tap').test;
 
-var react = require('../react');
+var react = require('../'); // require('react');
+var EventCollector = require('../lib/event-collector');
 
 function load(res, cb) { cb(null, res + '-loaded'); }
 function prefix(prefstr, str, cb) { cb(null, prefstr + str); }
@@ -38,6 +39,31 @@ test('mixed', function (t) {
   });
 });
 
+test('ast.defined event called when ast is defined', function (t) {
+  var fn = react();
+  var collector = new EventCollector();
+  collector.capture(fn, 'ast.*');
+  
+  var errors = fn.setAndValidateAST({
+    inParams: ['res', 'prefstr', 'poststr'],
+    tasks: [
+      { f: load,    a: ['res'],              out: ['lres'] },
+      { f: upper,   a: ['lres'],             out: ['ulres'], type: 'ret'  },
+      { f: prefix,  a: ['prefstr', 'ulres'], out: ['plres'] },
+      { f: postfix, a: ['plres', 'poststr'], out: ['plresp'] }
+    ],
+    outTask: { a: ['plresp'] }
+  });
+
+  var events = collector.list();
+  t.equal(events.length, 1);
+  t.type(events[0].ast, 'object');
+  t.ok(events[0].ast.inParams);
+  t.ok(events[0].ast.tasks);
+  t.ok(events[0].ast.outTask);
+  t.end();
+});
+
 test('cb with err', function (t) {
   t.plan(5);
   

package/test/core.test.js

@@ -3,12 +3,14 @@
 var test = require('tap').test;
 
 var react = require('../react');
+var EventCollector = require('../lib/event-collector');  // require('react/lib/event-collector'); // turn on tracking and get EventCollector
 
 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; }
+var anonFn = function (a, b) { return a + b; };
 
 test('set and validate AST', function (t) {
   var fn = react();
@@ -41,16 +43,19 @@ test('unnamed tasks will be assigned unique names', function (t) {
       { 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: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret' },
       { f: multiply, a: ['a', 'b'], out: ['f'] }
     ],
     outTask: { a: ['c'] }
   });
   t.deepEqual(errors, [], 'should set and validate as true');
+  t.equal(fn.ast.name.slice(0, 'flow_'.length), 'flow_', 'generated flow name should start with flow_');
   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' }
+      { f: anonFn,   a: ['a', 'b'], out: ['g'], type: 'ret', name: 'task_3' },    
+      { f: multiply, a: ['a', 'b'], out: ['f'], type: 'cb', name: 'multiply_4' }
     ]);
   t.end();
 });
@@ -107,19 +112,17 @@ test('multi-step with after as nonarr fn', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
   
   fn(2, 3, function (err, c, d) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(d, 5);
+    var events = collector.list();
     t.equal(events.length, 2, 'should have seen one task compl events');
-    t.equal(events[0].name, 'add', 'name matches');
-    t.equal(events[1].name, 'multiply', 'name matches');
+    t.equal(events[0].task.name, 'add', 'name matches');
+    t.equal(events[1].task.name, 'multiply', 'name matches');
     t.end();
   });
 });  
@@ -137,31 +140,29 @@ test('mixed multi-step with after as nonarr fn w/events', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
   
   fn(2, 3, function (err, c, d) {
     t.equal(err, null);
     t.equal(c, 6);
     t.equal(d, 5);
+    var events = collector.list();
     t.equal(events.length, 2, 'should have seen one task compl events');
-    t.equal(events[0].name, 'fnRetsSum', 'name matches');
-    t.ok(events[0].id, 'has unique id');
-    t.ok(events[0].startTime, 'has startTime');
-    t.ok(events[0].endTime, 'has endTime');
-    t.ok(events[0].elapsedTime !== undefined, 'has elapsedTime');    
-    t.ok(events[0].args, 'has args');
-    t.ok(events[0].results, 'has results');
-    t.equal(events[1].name, 'multiply', 'name matches');
-    t.ok(events[1].id, 'has unique id');
-    t.ok(events[1].startTime, 'has startTime');
-    t.ok(events[1].endTime, 'has endTime');
-    t.ok(events[1].elapsedTime !== undefined, 'has elapsedTime');    
-    t.ok(events[1].args, 'has args');
-    t.ok(events[1].results, 'has results');
+    t.equal(events[0].task.name, 'fnRetsSum', 'name matches');
+    t.ok(events[0].task.id, 'has unique id');
+    t.ok(events[0].task.startTime, 'has startTime');
+    t.ok(events[0].task.endTime, 'has endTime');
+    t.ok(events[0].task.elapsedTime !== undefined, 'has elapsedTime');    
+    t.ok(events[0].task.args, 'has args');
+    t.ok(events[0].task.results, 'has results');
+    t.equal(events[1].task.name, 'multiply', 'name matches');
+    t.ok(events[1].task.id, 'has unique id');
+    t.ok(events[1].task.startTime, 'has startTime');
+    t.ok(events[1].task.endTime, 'has endTime');
+    t.ok(events[1].task.elapsedTime !== undefined, 'has elapsedTime');    
+    t.ok(events[1].task.args, 'has args');
+    t.ok(events[1].task.results, 'has results');
     t.end();
   });
 });  
@@ -434,6 +435,27 @@ test('using "this" in a sync function', function (t) {
   }]);
 });
 
+test('undefined input arguments will be upgraded from undefined to null', function (t) {
+  var fn = react();
+  function concat(a, b) {
+    return '' + a + b;    
+  }
+  var errors = fn.setAndValidateAST({
+    inParams: ['a', 'b'],
+    tasks: [
+      { f: concat, a: ['a', 'b'], out: ['c'], type: 'ret' }
+    ],
+    outTask: { a: ['c'] }
+  });
+  t.deepEqual(errors, [], 'no validation errors');
+  fn('first', undefined, function (err, c) {  // undefined second param, upgrade to null
+    t.equal(err, null);
+    t.equal(c, 'firstnull');
+    t.end();
+  });
+});
+
+
 
 // Select first tests
 
@@ -451,18 +473,16 @@ test('selectFirst with first succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
   fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 6);
+    var events = collector.list();
     t.equal(events.length, 1, 'should have seen one task compl events');
-    t.equal(events[0].name, 'multiply', 'name matches');
-    t.deepEqual(events[0].results, [6], 'results match');
+    t.equal(events[0].task.name, 'multiply', 'name matches');
+    t.deepEqual(events[0].task.results, [6], 'results match');
     t.end();
   });
 });  
@@ -484,18 +504,16 @@ test('selectFirst with third succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
   fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[2].name, 'add', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[2].task.name, 'add', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });  
@@ -521,20 +539,18 @@ test('selectFirst forces order with third succeeding', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
   fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[0].name, 'noSuccess', 'name matches');
-    t.equal(events[1].name, 'noSuccessNull', 'name matches');
-    t.equal(events[2].name, 'add', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[0].task.name, 'noSuccess', 'name matches');
+    t.equal(events[1].task.name, 'noSuccessNull', 'name matches');
+    t.equal(events[2].task.name, 'add', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });  
@@ -560,18 +576,16 @@ test('selectFirst using direct returns', function (t) {
   });
   t.deepEqual(errors, [], 'no validation errors');
 
-  var events = [];
-  function accumEvents(task) {
-    events.push(task);
-  }
-  fn.events.on('task.complete', accumEvents);
+  var collector = new EventCollector();
+  collector.capture(fn, 'task.complete');
 
   fn(2, 3, function (err, c) {
     t.equal(err, null);
     t.equal(c, 5);
+    var events = collector.list();
     t.equal(events.length, 3, 'should have seen three task compl events');
-    t.equal(events[2].name, 'addRet', 'name matches');
-    t.deepEqual(events[2].results, [5], 'results match');
+    t.equal(events[2].task.name, 'addRet', 'name matches');
+    t.deepEqual(events[2].task.results, [5], 'results match');
     t.end();
   });
 });