react 0.6.3 → 0.9.0-rc1

package/test/ret-task.mocha.js

@@ -1,220 +0,0 @@
-'use strict';
-/*global react:true RetTask:true VContext:true */
-
-if (typeof(chai) === 'undefined') {
-  var chai = require('chai');
-}
-
-if (typeof(react) === 'undefined') {
-  var react = require('../'); //require('react');
-}
-
-if (typeof(RetTask) === 'undefined') {
-  var RetTask = require('../lib/ret-task.js');
-}
-
-if (typeof(VContext) === 'undefined') {
-  var VContext = require('../lib/vcon.js');
-}
-
-(function () {
-
-  var t = chai.assert;
-
-  /**
-     Testing VContext
-  */
-
-  suite('ret-task');
-
-  function foo() { }
-  function bar() { }
-  function cat() { }
-
-  test('new task is not complete', function (done) {
-    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [] });
-    t.equal(task.isComplete(), false);
-    done();
-  });
-
-  test('ready task is not complete', function (done) {
-    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'ready'});
-    t.equal(task.isComplete(), false);
-    done();
-  });
-
-  test('running task is not complete', function (done) {
-    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'running'});
-    t.equal(task.isComplete(), false);
-    done();
-  });
-
-  test('complete task is complete', function (done) {
-    var task = new RetTask({ type: 'ret', f: foo, a: [], out: [], status: 'complete' });
-    t.equal(task.isComplete(), true);
-    done();
-  });
-
-  test('task with any status is not ready', function (done) {
-    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);
-    done();  
-  });
-
-  test('no args defined, no after -> not ready', function (done) {
-    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);
-    done();
-  });
-
-  test('obj prop undefined -> NOT ready', function (done) {
-    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);
-    done();  
-  });
-
-  test('all args defined, no after, out no obj parent -> NOT ready', function (done) {
-    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');  
-    done();  
-  });
-
-  test('all args defined, no after, out no obj.par.par -> NOT ready', function (done) {
-    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');  
-    done();  
-  });
-
-  test('all args defined, no after, out null obj parent -> NOT ready', function (done) {
-    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');  
-    done();  
-  });
-
-  test('all args defined, no after, out null obj.par.par -> NOT ready', function (done) {
-    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');  
-    done();  
-  });
-
-  test('all args defined, no after -> ready', function (done) {
-    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);
-    done();  
-  });
-
-  test('all args defined, obj prop null, no after -> ready', function (done) {
-    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);
-    done();  
-  });
-
-  test('all args defined, after not complete -> NOT ready', function (done) {
-    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);  
-    done();  
-  });
-
-  test('all args defined, after all complete -> ready', function (done) {
-    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);  
-    done();  
-  });
-
-  test('string without . is not method call', function (done) {
-    var task = new RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
-    t.equal(task.isMethodCall(), false);
-    task.f = null;
-    t.equal(task.isMethodCall(), false);
-    done();
-  });
-
-  test('string with . is method call', function (done) {
-    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);
-    done();
-  });
-
-  test('undefined or null fn - functionExists', function (done) {
-    var task = new RetTask({ type: 'ret', f: 'foo', a: [], out: ['b'] });
-    var vCon = VContext.create([], []);
-    task.f = null;
-    t.isFalse(task.functionExists(vCon));
-    task.f = undefined;
-    t.isFalse(task.functionExists(vCon));
-    task.f = 'foo';
-    t.isFalse(task.functionExists(vCon));
-    vCon.values.foo = { };
-    task.f = 'foo.bar';
-    t.isFalse(task.functionExists(vCon));
-    done();
-  });
-
-  test('functionExists', function (done) {
-    var task = new RetTask({ type: 'ret', f: foo, a: [], out: ['b'] });
-    var vCon = VContext.create([], []);
-    t.isTrue(task.functionExists(vCon));
-    done();
-  });
-
-  test('method functionExists', function (done) {
-    var task = new RetTask({ type: 'ret', f: 'foo.b', a: [], out: ['b'] });
-    var vCon = VContext.create([{b: bar}], ['foo']);
-    t.isTrue(task.functionExists(vCon));
-    task.f = 'foo.bar.cat';
-    vCon.values.foo = { bar: { cat: cat}};
-    t.isTrue(task.functionExists(vCon));
-    done();
-  });
-
-  test('getMethodObj non-existent return undefined', function (done) {
-    var task = new RetTask({ type: 'ret', f: 'foo.b.c', a: [], out: ['b'] });
-    var vCon = VContext.create([{}], ['foo']);
-    t.equal(task.getMethodObj(vCon), undefined);
-    done();
-  });
-
-  test('getMethodObj returns object', function (done) {
-    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});
-    done();
-  });
-
-}());  

package/test/task.mocha.js

@@ -1,42 +0,0 @@
-'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 ...
-  */
-
-  suite('task');
-
-  function foo() { }
-  function bar() { }
-
-  test('missing types are guessed from params', function (done) {
-    var ast = {
-      inParams: ['a'], 
-      tasks: [
-        { f: foo, a: ['a'], out: ['baz'] },
-      ],
-      outTask: { a: ['baz'] }
-    };
-    taskUtil.setMissingType(ast.tasks[0]);
-    t.equal(ast.tasks[0].type, 'cb');
-    done();
-  });
-
-}());  

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

@@ -1,100 +0,0 @@
-'use strict';
-/*global react:true util:true sprintf:true validate:true */
-
-if (typeof(chai) === 'undefined') {
-  var chai = require('chai');
-}
-
-if (typeof(react) === 'undefined') {
-  var react = require('../'); //require('react');
-}
-
-if (typeof(util) === 'undefined') {
-  var util = require('util');
-}
-
-if (typeof(sprintf) === 'undefined') {
-  var sprintf = require('../lib/sprintf');
-}
-
-if (typeof(validate) === 'undefined') {
-  var validate = require('../lib/validate.js');
-}
-
-(function () {
-
-  var t = chai.assert;
-
-  /**
-     Testing validation of cb tasks
-  */
-
-  suite('validate-cb-task');
-
-  function foo() { }
-
-
-  test('cbTask requires f, a, out', function (done) {
-    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]);  
-    done();
-  });
-  
-  test('cbTask verifies f type', function (done) {
-    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]);
-    done();
-  });
-
-  test('cbTask verifies a type', function (done) {
-    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]);  
-    done();
-  });
-
-  test('cbTask verifies out type', function (done) {
-    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]);  
-    done();
-  });
-
-}());

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

@@ -1,110 +0,0 @@
-'use strict';
-/*global react:true util:true sprintf:true validate:true */
-
-if (typeof(chai) === 'undefined') {
-  var chai = require('chai');
-}
-
-if (typeof(react) === 'undefined') {
-  var react = require('../'); //require('react');
-}
-
-if (typeof(util) === 'undefined') {
-  var util = require('util');
-}
-
-if (typeof(sprintf) === 'undefined') {
-  var sprintf = require('../lib/sprintf');
-}
-
-if (typeof(validate) === 'undefined') {
-  var validate = require('../lib/validate.js');
-}
-
-(function () {
-
-  var t = chai.assert;
-
-  /**
-     Testing validation of return task
-  */
-
-  suite('validate-ret-task');
-
-  function foo() { }
-
-
-  test('retTask requires f, a, out', function (done) {
-    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]);  
-    done();
-  });
-  
-  test('retTask verifies f type', function (done) {
-    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]);
-    done();
-  });
-
-  test('retTask verifies a type', function (done) {
-    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]);  
-    done();
-  });
-
-  test('retTask verifies out type', function (done) {
-    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]);  
-    done();
-  });
-
-  test('valid retTask', function (done) {
-    var ast = {
-      inParams: ['a'], 
-      tasks: [{ type: 'ret', f: foo, a: [], out: ['bar'] }],
-      outTask: { a: ['bar'] }
-    };
-    t.deepEqual(validate(ast), []);  
-    done();
-  });
-
-}());