react 0.3.5 → 0.6.0

package/test/cb-task.mocha.js

@@ -0,0 +1,220 @@
+'use strict';
+/*global react:true CbTask:true VContext:true */
+
+if (typeof(chai) === 'undefined') {
+  var chai = require('chai');
+}
+
+if (typeof(react) === 'undefined') {
+  var react = require('../'); //require('react');
+}
+
+if (typeof(CbTask) === 'undefined') {
+  var CbTask = require('../lib/cb-task.js');
+}
+
+if (typeof(VContext) === 'undefined') {
+  var VContext = require('../lib/vcon.js');
+}
+
+(function () {
+
+  var t = chai.assert;
+
+  /**
+     Testing callback tasks
+  */
+
+  suite('cb-task');
+
+  function foo() { }
+  function bar() { }
+  function cat() { }
+
+  test('new task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: []});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('ready task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'ready'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('running task is not complete', function (done) {
+    var task = new CbTask({ type: 'cb', f: foo, a: [], out: [], status: 'running'});
+    t.equal(task.isComplete(), false);
+    done();
+  });
+
+  test('complete task is complete', function (done) {
+    var task = new CbTask({ type: 'cb', 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 CbTask({ type: 'cb', 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 CbTask({ type: 'cb', f: foo, a: ['b'], out: [] });
+    var vCon = VContext.create([], []);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), false);
+    done();
+  });
+
+  test('objprop undefined -> NOT ready', function (done) {
+    var task = new CbTask({ type: 'cb', 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 CbTask({ type: 'cb', 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 CbTask({ type: 'cb', 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 CbTask({ type: 'cb', 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 CbTask({ type: 'cb', 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 CbTask({ type: 'cb', f: foo, a: ['b', 'c'], out: ['d'] });
+    var vCon = VContext.create([1, null], ['b', 'c']);
+    var tasksByName = { foo: task };
+    t.equal(task.isReady(vCon, tasksByName), true);
+    done();  
+  });
+
+  test('all args defined, objprop null, no after -> ready', function (done) {
+    var task = new CbTask({ type: 'cb', 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 CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'running' });
+    var task = new CbTask(
+      { type: 'cb', 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 CbTask({ type: 'cb', f: cat, a: [], out: [], status: 'complete' });
+    var tbar = new CbTask({ type: 'cb', f: bar, a: [], out: [], status: 'complete' });
+    var task = new CbTask(
+      { type: 'cb', 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 CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+    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 CbTask({ type: 'cb', f: 'foo.bar', a: [], out: [] });
+    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 CbTask({ type: 'cb', f: 'foo', a: [], out: [] });
+    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 CbTask({ type: 'cb', f: foo, a: [], out: [] });
+    var vCon = VContext.create([], []);
+    t.isTrue(task.functionExists(vCon));
+    done();
+  });
+
+  test('method functionExists', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.isTrue(task.functionExists(vCon));
+    task.f = 'foo.bar.cat';
+    vCon.values.foo = { bar: { cat: cat}};
+    t.isNotNull(task.functionExists(vCon));
+    done();
+  });
+
+  test('getMethodObj non-existent return undefined', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b.c', a: [], out: [] });
+    var vCon = VContext.create([{}], ['foo']);
+    t.equal(task.getMethodObj(vCon), undefined);
+    done();
+  });
+
+  test('getMethodObj returns object', function (done) {
+    var task = new CbTask({ type: 'cb', f: 'foo.b', a: [], out: [] });
+    var vCon = VContext.create([{b: bar}], ['foo']);
+    t.deepEqual(task.getMethodObj(vCon), { b: bar});
+    done();
+  });
+
+}());

package/test/core-deferred.mocha.js

@@ -0,0 +1,143 @@
+'use strict';
+/*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 () {
+
+  var t = chai.assert;
+
+  suite('core-deferred');
+
+  /**
+     Test core PromiseTasks using Deferred - jquery style promises
+  */
+
+  function multiply(x, y) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.resolve(x * y);
+    }, 10);
+    return deferred.promise();
+  }
+  function add(x, y) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.resolve(x + y);
+    }, 10);
+    return deferred.promise();
+  }
+
+  function badFunc(a, b) {
+    throw new Error('badFuncThrow');
+  }
+
+  function badF2(a, b) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.reject(new Error('my-error'));
+    }, 10);
+    return deferred.promise();
+  }
+
+
+  test('multi-step', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [    
+        { f: multiply, a: ['a', 'b'], out: ['c'], type: 'promise' },
+        { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    fn(2, 3, function (err, c, d) {
+      t.equal(err, null);
+      t.equal(c, 6);
+      t.equal(d, 9);
+      done();
+    });
+  });  
+
+  test('using "this" in a cb function', function (done) {
+    function getA(cb) {
+      /*jshint validthis: true */
+      var deferred = new Deferred();
+      var self = this;
+      setTimeout(function () {
+        deferred.resolve(self.a);
+      }, 10);
+      return deferred.promise();
+    }
+    
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: [],
+      tasks: [    
+        { f: getA, a: [], out: ['a'], type: 'promise' }
+      ],
+      outTask: { a: ['a'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    var obj = {
+      a: 100
+    };
+
+    fn.apply(obj, [function (err, a) {
+      t.equal(err, null);
+      t.equal(a, 100);
+      done();
+    }]);
+  });
+
+
+  test('throws error', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [    
+        { f: badFunc, a: ['a', 'b'], out: ['c'], type: 'promise' },
+        { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    fn(2, 3, function (err, c, d) {
+      t.equal(err.message, 'badFuncThrow');
+      done();
+    });
+  });
+
+  test('rejects with error', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['a', 'b'],
+      tasks: [    
+        { f: badF2, a: ['a', 'b'], out: ['c'], type: 'promise' },
+        { f: add, a: ['c', 'b'], out: ['d'], type: 'promise' }
+      ],
+      outTask: { a: ['c', 'd'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    fn(2, 3, function (err, c, d) {
+      t.equal(err.message, 'my-error');
+      done();
+    });
+  });
+
+}());  

package/test/core-when.mocha.js

@@ -0,0 +1,96 @@
+'use strict';
+/*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 () {
+
+  var t = chai.assert;
+
+  suite('core-when');
+
+  /**
+     Test core WhenTasks using Deferred
+  */
+
+  function multiply(x, y) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.resolve(x * y);
+    }, 10);
+    return deferred.promise();
+  }
+  function add(x, y) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.resolve(x + y);
+    }, 10);
+    return deferred.promise();
+  }
+
+  function badF2(a, b) {
+    var deferred = new Deferred();
+    setTimeout(function () {
+      deferred.reject(new Error('my-error'));
+    }, 10);
+    return deferred.promise();
+  }
+
+
+  test('multi-step', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['pm', 'pa'],
+      tasks: [    
+        { a: ['pm'], out: ['m'], type: 'when' },
+        { a: ['pa'], out: ['a'], type: 'when' }
+      ],
+      outTask: { a: ['m', 'a'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    var pm = multiply(2, 3);
+    var pa = add(4, 5);
+    
+    fn(pm, pa, function (err, m, a) {
+      t.equal(err, null);
+      t.equal(m, 6);
+      t.equal(a, 9);
+      done();
+    });
+  });  
+
+
+  test('rejects with error', function (done) {
+    var fn = react();
+    var errors = fn.setAndValidateAST({
+      inParams: ['pm', 'pa'],
+      tasks: [    
+        { a: ['pm'], out: ['m'], type: 'when' },
+        { a: ['pa'], out: ['a'], type: 'when' }
+      ],
+      outTask: { a: ['m', 'a'] }
+    });
+    t.deepEqual(errors, [], 'no validation errors');
+
+    var pm = badF2(2, 3);
+    var pa = add(4, 5);
+
+    
+    fn(pm, pa, function (err, m, a) {
+      t.equal(err.message, 'my-error');
+      done();
+    });
+  });
+
+}());