react 0.7.0 → 0.9.0

package/test/validate.mocha.js

@@ -1,324 +0,0 @@
-/*global react:true util:true sprintf:true validate:true taskUtil: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');
-}
-
-if (typeof(taskUtil) === 'undefined') {
-  var taskUtil = require('../lib/task.js');
-}
-
-(function () {
-  'use strict';
-
-  var t = chai.assert;
-
-  /**
-     Testing ...
-  */
-
-  suite('validate');
-
-  function foo() { }
-  function bar() { }
-
-  test('empty ast is invalid', function (done) {
-    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']);
-    done();
-  });
-
-  test('ast.inParams must be an array of strings', function (done) {
-    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']);
-    done();
-  });
-
-  test('ast.tasks must be an array of tasks', function (done) {
-    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']);
-    done();
-  });
-
-  test('each task must be an object', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [1],  //err not array of objects
-      outTask: { a: ['bar'] }
-    };
-    t.deepEqual(validate(ast), ['task must be an object - 1']);
-    done();
-
-  });
-
-
-  test('each task in ast.tasks must match a valid task type', function (done) {
-    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',
-                      taskUtil.taskTypeKeys().join(', '), util.inspect(ast.tasks[0]));
-    t.deepEqual(validate(ast), [msg]);
-    done();
-  });
-
-  test('ast.outTask.a should be an array of string param names', function (done) {
-    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), []);
-    done();
-  });
-
-  test('ast.tasks that specify name need to be unique', function (done) {
-    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]);
-    done();
-  });
-
-  test('ast.locals should be non-null if passed in', function (done) {
-    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), []);
-    done();
-  });
-
-  test('non-method string functions need to map to fn in locals or in params', function (done) {
-    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]);
-    done();
-  });
-
-  test('string functions maps to fn in locals', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [{ f: 'cat.bar', a: [], out: ['bar'], type: 'ret' }],
-      outTask: { a: ['bar'] },
-      locals: { cat: { bar: foo }}
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('string functions maps to fn in inputs', function (done) {
-    var ast = {
-      inParams: ['a1', 'dog'],
-      tasks: [{ f: 'dog.food', a: [], out: ['bar'], type: 'ret' }],
-      outTask: { a: ['bar'] },
-      locals: { }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('string functions need to map to fn in locals or in params', function (done) {
-    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]);
-    done();
-  });
-
-  test('param func str fn need to map to fn in locals or in params', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [{ f: 'a', a: [], out: ['bar'], type: 'ret' }],
-      outTask: { a: ['bar'] },
-      locals: { }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('param obj exist func str needs map to fn in locals or in params', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [{ f: 'a.b', a: [], out: ['bar'], type: 'ret' }],
-      outTask: { a: ['bar'] },
-      locals: { }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('param obj !exist func str needs map to fn in locals or in params', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [{ f: 'd.e', a: [], out: ['bar'], type: 'ret' }],
-      outTask: { a: ['bar'] },
-      locals: { }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('multiple tasks output the same param, must be unique', function (done) {
-    var ast = {
-      inParams: ['a'],
-      tasks: [
-        { f: foo, a: [], out: ['baz', 'c'] },
-        { f: bar, a: [], out: ['c'] }
-      ],
-      outTask: { a: ['baz'] }
-    };
-    var msg = 'multiple tasks output the same param, must be unique. param: c';
-    t.deepEqual(validate(ast), [msg]);
-    done();
-  });
-
-  test('missing or mispelled input variable', function (done) {
-    var ast = {
-      inParams: [],
-      tasks: [
-        { f: foo, a: [], out: [] },
-        { f: bar, a: ['abc'], out: [] }
-      ],
-      outTask: { a: [] }
-    };
-    var msg = 'missing or mispelled variable referenced in flow definition: abc';
-    t.deepEqual(validate(ast), [msg]);
-    done();
-  });
-
-  test('missing or mispelled input variables', function (done) {
-    var ast = {
-      inParams: ['aaa', 'bbb'],
-      tasks: [
-        { f: foo, a: ['aaa', 'cat'], out: ['ccc'] },
-        { f: bar, a: ['abc', 'bbb', 'ccc'], out: [] }
-      ],
-      outTask: { a: [] }
-    };
-    var messages = [
-      'missing or mispelled variable referenced in flow definition: cat',
-      'missing or mispelled variable referenced in flow definition: abc'
-    ];
-    t.deepEqual(validate(ast), messages);
-    done();
-  });
-
-  test('missing or mispelled final output variables', function (done) {
-    var ast = {
-      inParams: ['aaa'],
-      tasks: [
-        { f: foo, a: ['aaa'], out: ['bbb'] },
-        { f: bar, a: ['bbb'], out: ['ccc'] }
-      ],
-      outTask: { a: ['ccc', 'ddd', 'eee'] }
-    };
-    var messages = [
-      'missing or mispelled variable referenced in flow definition: ddd',
-      'missing or mispelled variable referenced in flow definition: eee'
-    ];
-    t.deepEqual(validate(ast), messages);
-    done();
-  });
-
-  test('missing or mispelled validation ignores properties', function (done) {
-    var ast = {
-      inParams: ['obj'],
-      tasks: [
-        { f: foo, a: ['obj.foo'], out: [] },
-        { f: bar, a: ['obj.bar'], out: [] }
-      ],
-      outTask: { a: ['obj.cat'] }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-  test('missing or mispelled validation ignores literals', function (done) {
-    var ast = {
-      inParams: [],
-      tasks: [
-        { f: foo, a: ['true', 'false', '123', '123.1', 'null'], out: [] },
-        { f: bar, a: ['-123', '-123.4', '"wow"', "'hey'"], out: [] },
-        { f: foo, a: ['"two-words"', "'also-two'", '"two.words"', "'also.two'"], out: [] },
-        { f: foo, a: ['this'], out: [] }
-      ],
-      outTask: { a: [] }
-    };
-    t.deepEqual(validate(ast), []);
-    done();
-  });
-
-}());

package/test/vcon.mocha.js

@@ -1,193 +0,0 @@
-/*global react:true VContext:true */
-
-if (typeof(chai) === 'undefined') {
-  var chai = require('chai');
-}
-
-if (typeof(react) === 'undefined') {
-  var react = require('../'); //require('react');
-}
-
-if (typeof(VContext) === 'undefined') {
-  var VContext = require('../lib/vcon.js');
-}
-
-(function () {
-  'use strict';
-
-  var t = chai.assert;
-
-  /**
-     Testing Variable Context
-  */
-
-  suite('vcon');
-
-  test('VContext.create with empty args returns empty vCon', function (done) {
-    t.deepEqual(VContext.create([], []).values, {}, 'should be empty object');
-    t.deepEqual(VContext.create([], ['a']).values, {}, 'should be empty object');
-    done();
-  });
-
-  test('VContext.create with more args than params, ignore extra args', function (done) {
-    t.deepEqual(VContext.create([1], []).values, {}, 'should be empty object');
-    t.deepEqual(VContext.create([1, 2], ['a']).values, { a: 1 },
-                'should be object with one value');
-    done();
-  });
-
-  test('VContext.create sets vCon[paramName] to arg value', function (done) {
-    t.deepEqual(VContext.create([1, 2], ['a', 'b']).values, { a: 1, b: 2 },
-                'should have all values');
-    done();
-  });
-
-  test('create with locals is merged with args taking precedence', function (done) {
-    var locals = { a: 11, c: 30 };
-    t.deepEqual(VContext.create([1, 2], ['a', 'b'], locals).values,
-                { a: 1, c: 30, b: 2 }, 'should have merge of values');
-    done();
-  });
-
-  test('create with locals should not modify original locals', function (done) {
-    var locals = { a: 11, c: 30 };
-    t.deepEqual(VContext.create([1, 2], ['a', 'b'], locals).values,
-                { a: 1, c: 30, b: 2 }, 'should have merge of values');
-    t.deepEqual(locals, { a: 11, c: 30 }, 'should not modify original locals object');
-    done();
-  });
-
-  test('getVar on null returns null', function (done) {
-    t.equal(VContext.create([null], ['a']).getVar('a'), null);
-    t.equal(VContext.create([{ b: null }], ['a']).getVar('a.b'), null);
-    done();
-  });
-
-  test('getVar on undefined or null parent returns undefined', function (done) {
-    t.equal(VContext.create([], []).getVar('a'), undefined);
-    t.equal(VContext.create([], ['a']).getVar('a'), undefined);
-    t.equal(VContext.create([], ['a']).getVar('a.b'), undefined);
-    t.equal(VContext.create([], ['a']).getVar('a.b.c'), undefined);
-    t.equal(VContext.create([null], ['a']).getVar('a.b'), undefined);
-    t.equal(VContext.create([null], ['a']).getVar('a.b.c'), undefined);
-    t.equal(VContext.create([1], ['a']).getVar('a.b'), undefined);
-    t.equal(VContext.create([1], ['a']).getVar('a.b.c'), undefined);
-    done();
-  });
-
-  test('simple getVar returns existing value', function (done) {
-    t.equal(VContext.create([null], ['a']).getVar('a'), null);
-    t.equal(VContext.create([1], ['a']).getVar('a'), 1);
-    t.equal(VContext.create([true], ['a']).getVar('a'), true);
-    t.equal(VContext.create(['banana'], ['a']).getVar('a'), 'banana');
-    done();
-  });
-
-  test('getVar on literals returns the literal', function (done) {
-    t.equal(VContext.create([], []).getVar(true), true);
-    t.equal(VContext.create([], []).getVar(false), false);
-    t.equal(VContext.create([], []).getVar(null), null);
-    t.equal(VContext.create([], []).getVar('true'), true);
-    t.equal(VContext.create([], []).getVar('false'), false);
-    t.equal(VContext.create([], []).getVar('null'), null);
-    t.equal(VContext.create([], []).getVar(-100), -100);
-    t.equal(VContext.create([], []).getVar(100), 100);
-    t.equal(VContext.create([], []).getVar(123.4), 123.4);
-    t.equal(VContext.create([], []).getVar(-987.6), -987.6);
-    t.equal(VContext.create([], []).getVar('-100'), -100);
-    t.equal(VContext.create([], []).getVar('100'), 100);
-    t.equal(VContext.create([], []).getVar('123.4'), 123.4);
-    t.equal(VContext.create([], []).getVar('-987.6'), -987.6);
-    t.equal(VContext.create([], []).getVar('"foo"'), 'foo');
-    t.equal(VContext.create([], []).getVar("'foo'"), 'foo');
-    t.equal(VContext.create([], []).getVar("'foo.bar'"), 'foo.bar');
-    t.equal(VContext.create([], []).getVar("'foo-bar'"), 'foo-bar');
-    t.equal(VContext.create([], []).getVar("'foo-bar.json'"), 'foo-bar.json');
-    t.equal(VContext.create([], []).getVar('"foo-bar.json"'), 'foo-bar.json');
-    t.deepEqual(VContext.create([], [], null, { a: 1}).getVar('this'), { a: 1});
-    done();
-  });
-
-  test('getVar for property returns the property', function (done) {
-    var o = { b: 100};
-    t.equal(VContext.create([o], ['a']).getVar('a.b'), 100);
-    o = { b: { c: 200 }};
-    t.equal(VContext.create([o], ['a']).getVar('a.b.c'), 200);
-    done();
-  });
-
-  test('setVar will create objects if needed', function (done) {
-    var v = VContext.create([], []);
-    v.setVar('foo.bar.baz', 100);
-    t.deepEqual(v.values, { foo: { bar: { baz: 100}}});
-    done();
-  });
-
-  test('simple setVar', function (done) {
-    var v = VContext.create([], []);
-    v.setVar('foo', 100);
-    t.deepEqual(v.values, { foo: 100});
-    done();
-  });
-
-  test('setVar will not affect other vars', function (done) {
-    var v = VContext.create([{ bar: 1}], ['foo']);
-    v.setVar('foo.baz', 2);
-    t.deepEqual(v.values, { foo: { bar: 1, baz: 2 }});
-    done();
-  });
-
-  test('setVar with null key, will not set anything', function (done) {
-    var v = VContext.create([{ bar: 1}], ['foo']);
-    v.setVar(null, 2);
-    t.deepEqual(v.values, { foo: { bar: 1 }});
-    done();
-  });
-
-  test('setVar with undefined key, will not set anything', function (done) {
-    var v = VContext.create([{ bar: 1}], ['foo']);
-    v.setVar(undefined, 2);
-    t.deepEqual(v.values, { foo: { bar: 1 }});
-    done();
-  });
-
-  test('saveResults will set values for params and :LAST_RESULTS', function (done) {
-    var v = VContext.create([], []);
-    v.saveResults(['foo', 'bar', 'cat'], [1, 'hello', null]);
-    t.deepEqual(v.values, { foo: 1, bar: 'hello', cat: null,
-                            ':LAST_RESULTS': [1, 'hello', null] });
-    done();
-  });
-
-  test('saveResults set :LAST_RESULT w/all even params is short', function (done) {
-    var v = VContext.create([], []);
-    v.saveResults(['foo'], [1, 'hello', null]);
-    t.deepEqual(v.values, { foo: 1,
-                            ':LAST_RESULTS': [1, 'hello', null] });
-    done();
-  });
-
-  test('saveResults will set values for params and :LAST_RESULTS', function (done) {
-    var v = VContext.create([], []);
-    v.saveResults(['foo', 'bar', 'cat'], [1, 'hello', null]);
-    t.deepEqual(v.values, { foo: 1, bar: 'hello', cat: null,
-                            ':LAST_RESULTS': [1, 'hello', null] });
-    done();
-  });
-
-  test('saveResults upgrades undefined to null, but :LAST_RESULT is exact', function (done) {
-    var v = VContext.create([], []);
-    v.saveResults(['foo', 'bar', 'baz'], [1, undefined]);
-    t.deepEqual(v.values, { foo: 1, bar: null, baz: null,
-                            ':LAST_RESULTS': [1, undefined] });
-    done();
-  });
-
-  test('saveResults null params skips saving, :LAST_RESULT is exact', function (done) {
-    var v = VContext.create([], []);
-    v.saveResults(['foo', null], [1, 20]); //skip second param
-    t.deepEqual(v.values, { foo: 1, ':LAST_RESULTS': [1, 20] });
-    done();
-  });
-
-}());