react 0.5.2 → 0.6.3

package/test/finalcb-task.test.js

@@ -1,38 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-
-var tskutil = require('../lib/task.js');
-
-
-test('undefined cb throws exception', function (t) {
-  var fn = function () {
-    var finalTask = tskutil.createOutTask({}, 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 = tskutil.createOutTask({}, 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 = tskutil.createOutTask({}, 'foo');
-  };
-  t.throws(fn, new Error('callback is not a function'));
-  t.end();
-});
-
-test('valid fn creates outTask', function (t) {
-  function foo() { }
-  var finalTask = tskutil.createOutTask({ a: ['bar', 'baz']}, foo);
-  t.equal(finalTask.f, foo);
-  t.deepEqual(finalTask.a, ['bar', 'baz']);
-  t.end();
-});

package/test/input-parser.test.js

@@ -1,66 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-
-var inputParser = require('../lib/input-parser.js');
-
-test('parser parses input args', function (t) {
-  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);
-  t.end();
-});
-
-test('parser parses input args with cb', function (t) {
-  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);
-  t.end();
-});
-
-test('parser parses input args with cb and extra args', function (t) {
-  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);
-  t.end();
-});
-
-test('parser parses input args with extra args', function (t) {
-  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]);
-  t.end();
-});
-
-test('parser pulls react exec option off arg list', function (t) {
-  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 });
-  t.end();
-});
-
-test('parser pulls react exec options off arg list and merges from left to right', function (t) {
-  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' });
-  t.end();
-});
-

package/test/module-use.test.js

@@ -1,134 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-var BaseTask = require('../lib/base-task.js');
-
-var react = require('../'); // require('react');
-// turn on tracking, obtain EventCollector
-var EventCollector = require('../lib/event-collector');  // require('react/lib/event-collector'); 
-
-
-/**
-  @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 (t) {
-  t.type(react, 'function', 'is a core constructor and default dsl function');
-  t.type(react.options, 'object', 'has property for global react options');
-  t.type(react.events, 'object', 'has global react event manager');
-  t.type(react.logEvents, 'function', 'has function to enable event logging');
-  t.type(react.trackTasks, 'function', 'has function to enable task and flow tracking');
-  t.type(react.resolvePromises, 'function', 'has fn to enable promise detection & resolution');
-  t.end();
-});
-
-function foo() { }
-function bar() { }
-
-test('calling react constructor function creates new function with ast', function (t) {
-  var r = react();
-  t.type(r, 'function', 'is a function ready to execute flow');
-  t.type(r.ast, 'object', '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' });
-  t.end();
-});
-
-test('setAndValidateAST sets the ast and validates returning errors', function (t) {
-  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'); 
-  t.end();
-});
-
-test('use react() default DSL from module', function (t) {
-  t.plan(3);
-  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);
-    t.end();
-  });
-});
-
-test('use react.selectFirst() default DSL 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 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 = new EventCollector();
-  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');
-    t.end();
-  });
-});
-
-
-
-
-
-

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

@@ -1,52 +0,0 @@
-'use strict';
-
-/**
-  Test that arguments which are promises are automatically resolved
-  before calling react functions
-  */
-
-var test = require('tap').test;
-var Deferred = require('promised-io/promise').Deferred;
-
-var react = require('../');  // require('react');
-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 (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');
-
-  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);
-    t.end();
-  });
-});

package/test/ret-task.test.js

@@ -1,199 +0,0 @@
-'use strict';
-
-var test = require('tap').test;
-
-var RetTask = require('../lib/ret-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 RetTask({ type: 'ret', f: foo, a: [], out: [] });
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('ready task is not complete', function (t) {
-  var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'ready'});
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('running task is not complete', function (t) {
-  var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'running'});
-  t.equal(task.isComplete(), false);
-  t.end();
-});
-
-test('complete task is complete', function (t) {
-  var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: foo, a: ['b'], out: [] });
-  var vCon = VContext.create([], []);
-  var tasksByName = { foo: task };
-  t.equal(task.isReady(vCon, tasksByName), false);
-  t.end();
-});
-
-test('obj prop undefined -> NOT ready', function (t) {
-  var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: foo, a: ['b', 'c'], out: [] });
-  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, obj prop null, no after -> ready', function (t) {
-  var task = new RetTask({ type: 'ret', 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 RetTask({ type: 'ret', f: cat, a: [], out: [], status: 'complete' });
-  var tbar = new RetTask({ type: 'ret', f: bar, a: [], out: [], status: 'running' });
-  var task = new RetTask(
-    { type: 'ret', 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 RetTask({ type: 'ret', f: cat, a: [], out: [], status: 'complete' });
-  var tbar = new RetTask({ type: 'ret', f: bar, a: [], out: [], status: 'complete' });
-  var task = new RetTask(
-    { type: 'ret', 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 RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
-  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 RetTask({ type: 'ret', f: 'foo.bar', a: [], out: ['b'] });
-  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 RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
-  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 RetTask({ type: 'ret', f: foo, a: [], out: ['b'] });
-  var vCon = VContext.create([], []);
-  t.ok(task.functionExists(vCon));
-  t.end();
-});
-
-test('method functionExists', function (t) {
-  var task = new RetTask({ type: 'ret', f: 'foo.b', a: [], out: ['b'] });
-  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 RetTask({ type: 'ret', f: 'foo.b.c', a: [], out: ['b'] });
-  var vCon = VContext.create([{}], ['foo']);
-  t.equal(task.getMethodObj(vCon), undefined);
-  t.end();
-});
-
-test('getMethodObj returns object', function (t) {
-  var task = new RetTask({ type: 'ret', f: 'foo.b', a: [], out: ['b'] });
-  var vCon = VContext.create([{b: bar}], ['foo']);
-  t.deepEqual(task.getMethodObj(vCon), { b: bar});
-  t.end();
-});
-
-
-