react 0.7.0 → 0.9.0

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

@@ -1,68 +0,0 @@
-/*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 () {
-  'use strict';
-
-  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();
-    });
-  });
-
-}());

package/test/ret-task.mocha.js

@@ -1,220 +0,0 @@
-/*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 () {
-  'use strict';
-
-  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 @@
-/*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 () {
-  'use strict';
-
-  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 @@
-/*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 () {
-  'use strict';
-
-  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 @@
-/*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 () {
-  'use strict';
-
-  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();
-  });
-
-}());