react 0.0.3 → 0.2.2

package/test/ret-task.test.js

@@ -0,0 +1,199 @@
+'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();
+});
+
+
+

package/test/task.test.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var test = require('tap').test;
+
+var tutil = require('../lib/task.js');
+
+function foo() { }
+function bar() { }
+
+test('missing types are guessed from params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [
+      { f: foo, a: ['a'], out: ['baz'] },
+    ],
+    outTask: { a: ['baz'] }
+  };
+  tutil.setMissingType(ast.tasks[0]);
+  t.equal(ast.tasks[0].type, 'cb');
+  t.end();
+});

package/test/validate-cb-task.test.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var test = require('tap').test;
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+
+var validate = require('../lib/validate.js');
+
+function foo() { }
+
+
+test('cbTask requires f, a, out', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'cb' }],
+    outTask: { a: ['bar'] }
+  };
+  var msg = sprintf('cbTask requires f, a, out - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+  
+test('cbTask verifies f type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'cb', f: foo, a: [], out: [] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].f = 123; //err should be fn or string
+  var msg = sprintf('cbTask requires f to be a function or string - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);
+  t.end();
+});
+
+test('cbTask verifies a type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'cb', f: foo, a: [], out: [] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].a = 'foo'; //err should be arr of strings
+  var msg = sprintf('cbTask requires a to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast = Object.create(ast);
+  ast.tasks[0].a = ['foo', 1]; //err should be arr of strings
+  msg = sprintf('cbTask requires a to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+
+test('cbTask verifies out type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'cb', f: foo, a: [], out: [] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].out = 'foo'; //err should be arr of strings
+  var msg = sprintf('cbTask requires out to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast = Object.create(ast);
+  ast.tasks[0].out = ['foo', 1]; //err should be arr of strings
+  msg = sprintf('cbTask requires out to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+

package/test/validate-ret-task.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var test = require('tap').test;
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+
+var validate = require('../lib/validate.js');
+
+function foo() { }
+
+
+test('retTask requires f, a, out', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'ret' }],
+    outTask: { a: ['bar'] }
+  };
+  var msg = sprintf('retTask requires f, a, out - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+  
+test('retTask verifies f type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].f = 123; //err should be fn or string
+  var msg = sprintf('retTask requires f to be a function or string - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);
+  t.end();
+});
+
+test('retTask verifies a type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].a = 'foo'; //err should be arr of strings
+  var msg = sprintf('retTask requires a to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast = Object.create(ast);
+  ast.tasks[0].a = ['foo', 1]; //err should be arr of strings
+  msg = sprintf('retTask requires a to be an array of string param names - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+
+test('retTask verifies out type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
+    outTask: { a: ['bar'] }
+  };
+  ast.tasks[0].out = 'foo'; //err should be array with single string or []
+  var msg = sprintf('retTask requires out to be an array with single string param name or [] - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast = Object.create(ast);
+  ast.tasks[0].out = 123; //err should be array with single string or []
+  msg = sprintf('retTask requires out to be an array with single string param name or [] - %s',
+                    util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+
+test('valid retTask', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
+    outTask: { a: ['bar'] }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});

package/test/validate.test.js

@@ -0,0 +1,218 @@
+'use strict';
+
+var test = require('tap').test;
+var util = require('util');
+var sprintf = require('sprintf').sprintf;
+
+var validate = require('../lib/validate.js');
+var tutil = require('../lib/task.js');
+
+function foo() { }
+function bar() { }
+
+test('empty ast is invalid', function (t) {
+  t.deepEqual(validate(), ['ast must be an object with inParams, tasks, and outTask']);
+  t.deepEqual(validate({}), ['ast must be an object with inParams, tasks, and outTask']);
+  t.deepEqual(validate({ inParams: [] }), ['ast must be an object with inParams, tasks, and outTask']);
+  t.deepEqual(validate({ tasks: [] }), ['ast must be an object with inParams, tasks, and outTask']);
+  t.deepEqual(validate({ tasks: [], outTask: {} }), ['ast must be an object with inParams, tasks, and outTask']);
+  t.deepEqual(validate({ outTask: {} }), ['ast must be an object with inParams, tasks, and outTask']);
+  t.end();
+});
+
+test('ast.inParams must be an array of strings', function (t) {
+  var ast = {
+    inParams: 'a',  //err should be an array
+    tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] }
+  };
+  t.deepEqual(validate(ast), ['ast.inParams must be an array of strings']);
+
+  ast.inParams = [1]; //err not an array of strings
+  t.deepEqual(validate(ast), ['ast.inParams must be an array of strings']);  
+  t.end();
+});
+
+test('ast.tasks must be an array of tasks', function (t) {
+  var ast = {
+    inParams: ['a'],
+    tasks: 'bar', //err should be array
+    outTask: { a: ['bar'] }
+  };
+  t.deepEqual(validate(ast), ['ast.tasks must be an array of tasks']);
+  t.end();
+});
+
+test('each task must be an object', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [1],  //err not array of objects
+    outTask: { a: ['bar'] }
+  };
+  t.deepEqual(validate(ast), ['task must be an object - 1']);  
+  t.end();
+  
+});
+
+
+test('each task in ast.tasks must match a valid task type', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ type: 'zoo', f: foo, a: [], out: ['bar'] }], //err wrong type
+    outTask: { a: ['bar'] }
+  };
+  var msg = sprintf('task.type should match one of %s - %s',
+                    tutil.taskTypeKeys().join(', '), util.inspect(ast.tasks[0]));
+  t.deepEqual(validate(ast), [msg]);
+  t.end();
+});
+
+test('ast.outTask.a should be an array of string param names', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }], 
+    outTask: { a: ['bar'] }
+  };
+  ast.outTask = {}; //err a should be an arr
+  var msg = sprintf('ast.outTask.a should be an array of string param names - %s',
+                    util.inspect({ type: 'finalcb' }));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast.outTask = { type: 'finalcb', a: 'bar' }; //err a should be an arr
+  msg = sprintf('ast.outTask.a should be an array of string param names - %s',
+                    util.inspect(ast.outTask));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast.outTask = { type: 'finalcb', a: ['bar', 1] }; //err a should be an arr of strings
+  msg = sprintf('ast.outTask.a should be an array of string param names - %s',
+                    util.inspect(ast.outTask));
+  t.deepEqual(validate(ast), [msg]);  
+
+  ast.outTask = { a: [] }; //valid
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('ast.tasks that specify name need to be unique', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [
+      { f: foo, a: [], out: ['bar'], name: 'dog' },
+      { f: foo, a: [], out: ['bar'], name: 'dog' }
+    ], 
+    outTask: { a: ['bar'] }
+  };
+  var msg = sprintf('ast.tasks that specify name need to be unique, duplicate: %s',
+                    'dog');
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+  
+test('ast.locals should be non-null if passed in', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: foo, a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: null  //err should be non-null if passed in
+  };
+  t.deepEqual(validate(ast), ['ast.locals should not be null']);
+
+  ast.locals = { };
+  t.deepEqual(validate(ast), []);
+  t.end();
+});
+
+test('non-method string functions need to map to fn in locals or in params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'foo', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { }
+  };
+  var msg = sprintf('function: %s not found in locals or input params - task[%s]', 
+                    'foo', 0);
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+
+test('string functions maps to fn in locals', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'cat.bar', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { cat: { bar: foo }}
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('string functions maps to fn in inputs', function (t) {
+  var ast = {
+    inParams: ['a1', 'dog'], 
+    tasks: [{ f: 'dog.food', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('string functions need to map to fn in locals or in params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'foo.bar', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { foo: {}}
+  };
+  var msg = sprintf('function: %s not found in locals or input params - task[%s]', 
+                    'foo.bar', 0);
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});
+
+test('param func str fn need to map to fn in locals or in params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'a', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('param obj exist func str needs map to fn in locals or in params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'a.b', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('param obj !exist func str needs map to fn in locals or in params', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [{ f: 'd.e', a: [], out: ['bar'], type: 'ret' }],
+    outTask: { a: ['bar'] },
+    locals: { }
+  };
+  t.deepEqual(validate(ast), []);  
+  t.end();
+});
+
+test('multiple tasks output the same param, must be unique', function (t) {
+  var ast = {
+    inParams: ['a'], 
+    tasks: [
+      { f: foo, a: [], out: ['baz', 'c'] },
+      { f: bar, a: [], out: ['c'] }
+    ], 
+    outTask: { a: ['bar'] }
+  };
+  var msg = 'multiple tasks output the same param, must be unique. param: c';
+  t.deepEqual(validate(ast), [msg]);  
+  t.end();
+});