react 0.5.2 → 0.6.3

package/test/exec-options.mocha.js

@@ -0,0 +1,48 @@
+'use strict';
+/*global react:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing exec options
+  */
+
+  suite('exec-options');
+
+  function multiply(x, y, cb) { cb(null, x * y); }
+
+  test('execOptions as first param', function (done) {
+    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: 'cb'
+    };
+    
+    fn(execOptions, 2, 3, function (err, c) {
+      t.equal(err, null);
+      t.equal(c, 6);
+      done();
+    });
+  });  
+
+
+}());

package/test/finalcb-task.mocha.js

@@ -0,0 +1,58 @@
+'use strict';
+/*global react:true taskUtil:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(taskUtil) === 'undefined') {
+  var taskUtil = require('../lib/task.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing final cb task
+  */
+
+  suite('finalcb-task');
+
+  test('undefined cb throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, undefined);
+    };
+    t.throws(fn, 'callback is not a function');
+    done();
+  });
+
+  test('null cb  throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, null);
+    };
+    t.throws(fn, 'callback is not a function');
+    done();
+  });
+
+  test('cb needs to be a function or throws exception', function (done) {
+    var fn = function () {
+      var finalTask = taskUtil.createOutTask({}, 'foo');
+    };
+    t.throws(fn, 'callback is not a function');
+    done();
+  });
+
+  test('valid fn creates outTask', function (done) {
+    function foo() { }
+    var finalTask = taskUtil.createOutTask({ a: ['bar', 'baz']}, foo);
+    t.equal(finalTask.f, foo);
+    t.deepEqual(finalTask.a, ['bar', 'baz']);
+    done();
+  });
+
+}());

package/test/input-parser.mocha.js

@@ -0,0 +1,86 @@
+'use strict';
+/*global react:true inputParser:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(inputParser) === 'undefined') {
+  var inputParser = require('../lib/input-parser.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing ...
+  */
+
+  suite('input-parser');
+
+  test('parser parses input args', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with cb', function (done) {
+    function foo() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, foo], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.cb, foo);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with cb and extra args', function (done) {
+    function foo() { }
+    var ast = { inParams: ['a', 'b'] };
+    var parsedInput = inputParser([10, 20, foo, 30, 40], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.cb, foo);
+    t.deepEqual(parsedInput.extraArgs, [30, 40]);
+    t.deepEqual(parsedInput.options, inputParser.defaultExecOptions);
+    done();
+  });
+
+  test('parser parses input args with extra args', function (done) {
+    var ast = { inParams: [] };
+    var execOptions = { reactExecOptions: true, outputStyle: 'none' };
+    var parsedInput = inputParser([execOptions, 10, 20], ast);
+    t.deepEqual(parsedInput.args, []);
+    t.deepEqual(parsedInput.extraArgs, [10, 20]);
+    done();
+  });
+
+  test('parser pulls react exec option off arg list', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var execOptions = { reactExecOptions: true, foo: 10 };
+    var parsedInput = inputParser([execOptions, 10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 10 });
+    done();
+  });
+
+  test('parser pulls react exec options off arg list and merges from left to right', function (done) {
+    function myCb() { }
+    var ast = { inParams: ['a', 'b'] };
+    var execOptions = { reactExecOptions: true, foo: 12, bar: 24 };
+    var execOptions2 = { reactExecOptions: true, bar: 36, baz: 'hello' };
+    var parsedInput = inputParser([execOptions, execOptions2, 10, 20, myCb], ast);
+    t.deepEqual(parsedInput.args, [10, 20]);
+    t.deepEqual(parsedInput.options, { reactExecOptions: true, outputStyle: 'cb', foo: 12, bar: 36, baz: 'hello' });
+    done();
+  });
+
+}());

package/test/log-events.mocha.js

@@ -0,0 +1,88 @@
+'use strict';
+/*global react:true BaseTask:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing turning on logging of events
+  */
+
+  suite('log-events');
+
+  /**
+     @example
+     var react = require('react');
+     react.logEvents(); // log to console
+  */
+
+  before(function () {
+    react.logEvents();
+  });
+
+  after(function () {
+    react.logEvents(false);
+  });
+
+  test('use react() default DSL from module', function (done) {
+    function multiply(a, b, cb) { cb(null, a * b); }
+    function add(a, b, cb) { cb(null, a + b); }
+    var fn = react('multiplyAdd', 'a, b, cb -> err, m, s',
+                   multiply, 'a, b, cb -> err, m',
+                   add, 'm, a, cb -> err, s'
+                  );
+
+
+    fn(2, 3, function (err, m, s) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(m, 6);
+      t.equal(s, 8);
+      done();
+    });
+  });
+
+  test('use react.selectFirst() default DSL with events', function (done) {
+    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 fn = react.selectFirst('mySelectFirst', 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c',
+                               noSuccessNull, 'a, b, cb -> err, c',
+                               add, 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c'
+                              );
+
+    var collector = react.createEventCollector();
+    collector.capture(fn, 'task.complete');
+
+    fn(2, 3, function (err, c) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(c, 5);
+      var events = collector.list();
+      t.equal(events.length, 3, 'should have seen two task compl events');
+      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');
+      done();
+    });
+  });
+
+}());
+
+
+
+

package/test/mocha.opts

@@ -0,0 +1,2 @@
+--reporter spec
+--ui qunit

package/test/module-use.mocha.js

@@ -0,0 +1,147 @@
+'use strict';
+/*global react:true BaseTask:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(BaseTask) === 'undefined') {
+  var BaseTask = require('../lib/base-task.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing the general use of react
+  */
+
+  suite('module-use');
+
+  /**
+     @example
+     var react = require('react');
+     react.options.an_option = 'something';
+
+     // define function
+     var loadAndSave = react('myName', 'one, two, cb -> err, result1, result2',
+     foo, 'one, cb      -> err, cat',
+     bar, 'two, cat, cb -> err, dog',
+     baz, 'dog, cb      -> err, result1',
+     bum, 'dog, cb      -> err, result2');
+
+     // OR using AST
+     
+     var loadAndSave = react();
+     loadAndSave.setAndValidateAST({
+     inParams: ['one', 'two'],
+     tasks: { },
+     outTask: { a: ['three'] }
+     });
+
+     //if you want to listen to task completion events
+     loadAndSave.events.on('task.complete', function (taskObj) { });
+
+     loadAndSave(1,2,cb); // execute like any other function
+  */
+
+  test('module exports an function object with properties', function (done) {
+    t.isFunction(react, 'is a core constructor and default dsl function');
+    t.isObject(react.options, 'has property for global react options');
+    t.isObject(react.events, 'has global react event manager');
+    t.isFunction(react.logEvents, 'has function to enable event logging');
+    t.isFunction(react.trackTasks, 'has function to enable task and flow tracking');
+    t.isFunction(react.resolvePromises, 'has fn to enable promise detection & resolution');
+    done();
+  });
+
+  function foo() { }
+  function bar() { }
+
+  test('calling react constructor function creates new function with ast', function (done) {
+    var r = react();
+    t.isFunction(r, 'is a function ready to execute flow');
+    t.isObject(r.ast, 'is object for inspecting AST');
+    t.deepEqual(r.ast.inParams, [],              'ast.inParams should return empty array');
+    t.deepEqual(r.ast.tasks, [],                 'ast.tasks() should return empty array');
+    t.deepEqual(r.ast.outTask, { a: [], type: 'finalcb' });
+    done();
+  });
+
+  test('setAndValidateAST sets the ast and validates returning errors', function (done) {
+    var r = react();
+    var errors = r.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [
+        { f: foo, a: ['a'], out: ['c'] },
+        { f: bar, a: ['b'], out: ['d'] }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(r.ast.inParams, ['a', 'b'],      'ast.inParams() should match array just set');
+    t.deepEqual(r.ast.tasks, [
+      { f: foo, a: ['a'], out: ['c'], type: 'cb', name: 'foo' },
+      { f: bar, a: ['b'], out: ['d'], type: 'cb', name: 'bar' }
+    ]);
+    t.deepEqual(r.ast.outTask, { a: ['c', 'd'], type: 'finalcb' },      'should return obj just set'); 
+    done();
+  });
+
+  test('use react() default DSL from module', function (done) {
+    function multiply(a, b, cb) { cb(null, a * b); }
+    function add(a, b, cb) { cb(null, a + b); }
+    var fn = react('multiplyAdd', 'a, b, cb -> err, m, s',
+                   multiply, 'a, b, cb -> err, m',
+                   add, 'm, a, cb -> err, s'
+                  );
+
+    
+    fn(2, 3, function (err, m, s) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(m, 6);
+      t.equal(s, 8);
+      done();
+    });
+  });
+
+  test('use react.selectFirst() default DSL with events', function (done) {
+    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 fn = react.selectFirst('mySelectFirst', 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c',
+                               noSuccessNull, 'a, b, cb -> err, c',
+                               add, 'a, b, cb -> err, c',
+                               noSuccess, 'a, b, cb -> err, c'                             
+                              );
+
+    var collector = react.createEventCollector();
+    collector.capture(fn, 'task.complete');
+    
+    fn(2, 3, function (err, c) {
+      t.deepEqual(err, null, 'should not be any error');
+      t.equal(c, 5);
+      var events = collector.list();
+      t.equal(events.length, 3, 'should have seen two task compl events');
+      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');
+      done();
+    });
+  });
+
+}());
+
+
+
+

package/test/promise-auto-resolve.mocha.js

@@ -0,0 +1,68 @@
+'use strict';
+/*global react:true Deferred:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(Deferred) === 'undefined') {
+  var Deferred = require('Deferred');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  suite('promise-auto-resolve');
+
+  /**
+     Test that arguments which are promises are automatically resolved
+     before calling react functions
+  */
+
+  react.resolvePromises(); // enable promise resolving
+
+  function multiply(x, y, cb) { cb(null, x * y); }
+  function add(x, y, cb) { cb(null, x + y); }
+  // function badF2(a, b, cb) { cb('my-error'); }
+
+  test('auto resolve promises passed as args', function (done) {
+    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');
+
+    function retAP() {
+      var deferred = new Deferred();
+      setTimeout(function () { deferred.resolve(2); }, 10);
+      return deferred.promise();
+    }
+
+    function retBP() {
+      var deferred = new Deferred();
+      setTimeout(function () { deferred.resolve(3); }, 10);
+      return deferred.promise();      
+    }
+
+    var ap = retAP();
+    var bp = retBP();
+
+    fn(ap, bp, function (err, c, d) {
+      t.equal(err, null);
+      t.equal(c, 6);
+      t.equal(d, 9);
+      done();
+    });
+  });
+
+}());