spade 0.0.1 → 0.0.2

data/packages/core-test/lib/qunit.js

@@ -1,159 +0,0 @@
-// ==========================================================================
-// Project:   CoreTest Unit Testing Library
-// Copyright: ©2010 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
-// ==========================================================================
-/*globals module test mod stop start expect ok equals same raises Ct */
-
-require('./core');
-var utils = require('./utils');
-
-    
-// internal function called to finish a phase
-function _finishPhase() {
-  var st = Ct.qUnitStatus, done = st.callback;
-
-  // invoke final handler...
-  if (st.final) st.final();
-  
-  // cleanup phase and resolve promise to move on
-  st.callback   = st.final = null;
-  st.isFinished = true;
-  st.isRunning  = true;
-  
-  if (done) done();
-}
-
-// starts a new module.  This is basically the same as CoreTest
-module = exports.module = function(moduleName, opts) {
-  Ct.module(moduleName);
-  
-  var setup = opts && opts.setup,
-      teardown = opts && opts.teardown;
-      
-  Ct.setup(function(t, done) {
-    
-    var st = {
-      test: t,
-      callback: done, // changes as we step through each phase
-      isFinished: false, // reset each phase
-      expect:  -1, // tests in teardown
-      assertions: 0,
-      isRunning: true // used by start/stop
-    };
-    Ct.qUnitStatus = st;
-
-    if (setup) setup();
-
-    st.isFinished = true;
-    if (st.isRunning) _finishPhase();
-  });
-
-  Ct.teardown(function(t, done) {
-    var st = Ct.qUnitStatus;
-        
-    st.callback = done ;
-    st.isFinished = false;
-    st.isRunning = true;
-    
-    // final code to run after teardown handler 
-    st.final = function() {
-      if (st.expects>=0) {
-        t.equal(st.assertions, st.expects, 'expected assertions');
-      }
-      Ct.qUnitStatus = null ;
-    };
-
-    if (teardown) teardown();
-    st.isFinished = true;
-    if (st.isRunning) _finishPhase();
-  });
-  
-};
-
-
-// adds a test.  We actually wrap an async test here so we can implement 
-// start, stop, and expect
-test = exports.test  = function(testName, handler) {
-  
-  if (!Ct.defaultPlan) exports.module('default');
-  
-  Ct.test(testName, function(t, done) {
-    var st = Ct.qUnitStatus;
-        
-    st.callback = done;
-    st.isFinished = false;
-    st.isRunning  = true;
-    
-    if (handler) handler(); else t.warn("Not Yet Implemented");
-    
-    st.isFinished = true;
-    if (st.isRunning) _finishPhase();
-  });
-  
-};
-
-// stops a test from finishing.  must be matched with a call to start() later
-stop = exports.stop = function() {
-  if (!Ct.qUnitStatus) throw "cannot call stop() outside of a unit test";
-  Ct.qUnitStatus.isRunning = false ;
-};
-
-// starts a test that was stopped.  Must be called after a call to start()
-start = exports.start = function() {
-  var st = Ct.qUnitStatus;
-
-  if (!st) throw "cannot call stop() outside of a unit test";
-  if (!st.isRunning && st.isFinished) _finishPhase();
-  else st.isRunning = true;
-};
-
-// set the expected assertions for the test
-expect = exports.expect = function(cnt) {
-  if (!Ct.qUnitStatus) throw "cannot call expect() outside of a unit test";
-  Ct.qUnitStatus.expects = cnt;
-};
-
-// ok assertion
-ok = exports.ok = function(value, message) {
-  if (!Ct.qUnitStatus) throw "cannot call ok() outside of a unit test";
-  if (message === undefined) message = 'ok';
-  Ct.qUnitStatus.assertions++;
-  Ct.qUnitStatus.test.ok(value, message);
-};
-
-// equals assertion
-equals = exports.equals = function(actual, expected, message) {
-  if (!Ct.qUnitStatus) throw "cannot call equals() outside of a unit test";
-  if (message === undefined) message = 'ok';
-  Ct.qUnitStatus.assertions++;
-  Ct.qUnitStatus.test.equal(actual, expected, message);
-};
-
-// same assertion
-same = exports.same = function(actual, expected, message) {
-  if (!Ct.qUnitStatus) throw "cannot call same() outside of a unit test";
-  if (message === undefined) message = 'same';
-  Ct.qUnitStatus.assertions++;
-  Ct.qUnitStatus.test.deepEqual(actual, expected, message);
-};
-
-raises = exports.raises = function(handler, err, message) {
-  if (!Ct.qUnitStatus) throw "cannot call raises() outside of a unit test";
-  if (err === true) {
-    err = message;
-    message = undefined;
-  }
-  Ct.qUnitStatus.assertions++;
-  Ct.qUnitStatus.test.throws(handler, err, message);
-};
-
-// Alias
-should_throw = exports.should_throw = exports.raises;
-
-exports.run = function() {
-  Ct.run();
-};
-
-
-

data/packages/core-test/lib/runner.js

@@ -1,65 +0,0 @@
-// ==========================================================================
-// Project:   SproutCore Unit Testing Library
-// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
-//            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
-// ==========================================================================
-/*globals __module */
-
-var Ct = require('./core');
-
-/**
-  The test runner allows you to register one or more modules.  It will then
-  step through the modules, requiring each one.  If run in the browser it 
-  can optionally look at the href and filter.
-*/
-var Runner = function() {
-  this.modules = [];
-};
-
-var Rp = Runner.prototype;
-
-/**
-  Pass one or more module ids.  
-*/
-Rp.register = function(args) {
-  var len = arguments.length, idx;
-  for(idx=0;idx<len;idx++) {
-    var mod = arguments[idx];
-    if ('string' === typeof mod) this.modules.push(mod);
-    else mod.forEach(function(m) { this.modules.push(m); }, this);
-  }
-  return this;
-};
-
-/**
-  Filters the current set of modules based on the href.  
-  TODO: implement
-*/
-Rp.filter = function() {
-  
-};
-
-Rp.finish = function() {
-  console.log('finished');
-};
-
-Rp.run = function() {
-  this.filter();
-  
-  this.modules.forEach(function(m) { 
-    var sb = require.sandbox(false); // TODO: Use isolated sandboxes
-    var sbCt = sb.require('core-test');
-
-    sbCt.defaultLogger = Ct.defaultLogger; // share logger
-    sb.require(m); 
-    sbCt.run();
-  });
-  
-  Ct.then(this, this.finish);
-  Ct.run();
-};
-
-__module.exports = exports = new Runner();
-exports.Runner = Runner;
-

data/packages/core-test/lib/spec.js

@@ -1,302 +0,0 @@
-// ==========================================================================
-// Project:   CoreTest Unit Testing Library
-// Copyright: ©2010 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
-// ==========================================================================
-/*globals describe before after it */
-
-/**
-  @file @private
-    
-  Implements a BDD-style specification API.  Example:
-  
-  {{{
-  
-    describe('some part of the app', function() {
-    
-      before(function() {
-        this.foo = 'bar';
-      });
-      
-      after(function() {
-        this.foo = null;
-      });
-      
-      it('should do something', function(val) {
-        val(this.foo).shouldBe('bar');
-      });
-      
-      describe('a nested part of the app', function() {
-        before(function(v) {
-          // also sets this.foo = 'bar' before this
-          this.bar = 10;
-        });
-        
-        it('should have foo and bar', function(v) {
-          v(this.foo).should.not().equal('bar');
-          v(this.bar).should.be.greaterThan(5);          
-          v.async();
-        
-          v(23).not().greaterThan(5);
-          
-          setTimeout(function() {
-            v.done();
-          });
-          
-        });
-      });
-      
-    });
-  }}}
-*/
-
-var Ct    =  require('./core'),
-    utils = require('./utils'),
-    fn;
-
-var state = {
-  beforeHandlers: [],
-  afterHandlers:  [],
-  moduleNames: [],
-  level: 0
-};
-
-function pushState(desc) {
-  
-  var next = {
-    beforeHandlers: state.beforeHandlers.slice(),
-    afterHandlers:  state.afterHandlers.slice(),
-    moduleNames:    state.moduleNames.slice(),
-    tests: [], 
-    level: state.level+1,
-    prevState: state
-  };
-  next.moduleNames.push(desc);
-  next.module = state.module ? state.module.module(desc) : Ct._defaultPlan().module(desc);
-  
-  state = next;
-}
-
-function popState() {
-  if (!state.prevState) {
-    throw "cannot popState when at top level";
-  }
-  state = state.prevState;
-}
-
-// Value handles assertions.  we generate a new closure with this.
-var Value = function(x, t) {
-  this.value = x;
-  this.test  = t;
-
-  // sweet sweet sugar
-  this.should = this;
-};
-exports.Value = Value;
-
-function mkval(t, done) {
-  var ret = function(x) {
-    return new Value(x, t);
-  };
-
-  ret.deferred = ret._isDone = false;
-  
-  /**
-    Puts the test into async mode.  You will need to call done() manually
-    to complete the test.
-  */
-  ret.async = function() {
-    this.deferred = true;
-    return this;
-  };
-  
-  /**
-    Call to finish a test.  Not required unless test is in async mode.
-  */
-  ret.done = function() {
-    if (!this._isDone) {
-      this._isDone = true;
-      done();
-    }
-    return this;
-  };
-
-  /**
-    Log an error to the test.
-  */
-  ret.error = function(msg) {
-    t.error(msg);
-    return this;
-  };
-  
-  /**
-    Log and informative statement to the test.
-  */
-  ret.info = function(msg) {
-    t.info(msg);
-    return this;
-  };
-  
-  ret.expect = function(cnt) {
-    t.expect(cnt);
-    return this;
-  };
-  
-  ret._finish = function() {
-    if (!this.deferred && !this._isDone) {
-      this._isDone = true;
-      done();
-    }
-  };
-  
-  return ret;
-}
-
-function unroll(handler, t, next, context) {
-  return function(err) {
-    if (err) return next(err);
-    var v = mkval(t, next);
-    handler.call(context, v);
-    v._finish(); // will invoke next...
-  };
-}
-
-/**
-  Top-level command that describes a currenet condition or state.  You can
-  nest calls to describe() but when the top level one exits is when we will
-  run the plan.
-*/
-describe = exports.describe = function describe(desc, handler, context) {
-  var loc, next, module;
-
-  // get a new state and start a new module
-  pushState(desc);
-  
-  // register generic setup/teardown handlers
-  var beforeHandlers = state.beforeHandlers,
-      afterHandlers  = state.afterHandlers;
-  
-  state.module.setup(function(t, done) {
-    loc = beforeHandlers.length;
-    next = done;
-    while(--loc>=0) next = unroll(beforeHandlers[loc], t, next, this);
-    next();
-  });
-
-  state.module.teardown(function(t, done) {
-    loc = afterHandlers.length;
-    next = done;
-    while(--loc>=0) next = unroll(afterHandlers[loc], t, next, this);
-    next();
-  });
-
-  // now invoke handler.  this will schedule tests or add before/after
-  handler.call(context);
-  
-  popState();
-  if (state.level === 0) Ct.run();
-};
-
-before = exports.before = function before(func) {
-  state.beforeHandlers.push(func);
-};
-
-after = exports.after = function after(func) {
-  state.afterHandlers.push(func);
-};
-
-// schedule a test in the current target module
-it = exports.it = function it(desc, func) {
-  if (!state.module) throw "cannot schedule test outside of context";
-  state.module.test(desc, function(t, done) {
-    var v = mkval(t, done);
-    func.call(this, v);
-    v._finish();
-  });
-};
-
-// ..........................................................
-// ASSERTIONS
-// 
-
-// assertion functions go here
-fn = exports.describe.fn = Value.prototype;
-
-/**
-  Inverts the next assertion.
-*/
-fn.not = function() {
-  this.inverted = !this.inverted;
-  return this;
-};
-
-/**
-  Assertion primitive
-*/
-fn.assert = function(pass, message, actual, expected) {
-  if (this.inverted) {
-    pass = !pass;
-    message = 'should not be'+message;
-  } else message = 'should be'+message;
-  this.test.assert(pass, message, actual, expected);
-  return this;
-};
-
-/**
-  Assert the passed value should be equal.
-*/
-fn.equal = function(expected, message) {
-  if (this.inverted) {
-    this.test.notEqual(this.value, expected, message);
-  } else {
-    this.test.equal(this.value, expected, message);
-  }
-  return this;
-};
-fn.equals = fn.be = fn.equal;
-
-/**
-  Assert the passed value should be same (with deep compare)
-*/
-fn.same = function(expected, message) {
-  if (this.inverted) {
-    this.test.notDeepEqual(this.value, expected, message);
-  } else {
-    this.test.deepEqual(this.value, expected, message);
-  }
-  return this;
-};
-fn.deepEqual = fn.beSame = fn.same;
-
-/**
-  Assert that is exact same value
-*/
-fn.identical = function(expected, message) {
-  if (this.inverted) {
-    this.test.notStrictEqual(this.value, expected, message);
-  } else {
-    this.test.strictEqual(this.value, expected, message);
-  }
-};
-fn.strictEqual = fn.beIdentical = fn.identical;
-
-fn.empty = function() {
-  var v = this.value,
-      isEmpty = (v===null) || (v===undefined) || (v.length === 0) || (v==='');
-  this.assert(isEmpty, 'empty', this.value, '');
-  return this;
-};
-fn.beEmpty = fn.empty;
-
-fn.contain = function(item) {
-  this.assert(this.value.indexOf(item)>=0, 'contain item', this.value, item);
-  return this;
-};
-
-
-
-
-
-
-
-