Refactor tests: switch to Mocha, make providers and filer source configurable. Fixes #59

Make provider configurable via URL. Convert fs.close test to use it. Still have timing issue with WebSQL.

Indent fix

Use bower to install mocha

Converting to mocha, Memory provider failing still in fs.close

Got mocha tests working with all providers

Converted more tests

Move more tests over to mocha

Move more tests over

Move more tests over

More tests moved over

More tests converted

More tests moved over

Move more tests over

Move last tests over

Convert more tests

Remove Jasmine and other unnecessary test files, rename tests/spec/regression to tests/bugs

Get tests running with grunt+mocha+phantomjs

Add docs on new tests

.gitignore

@@ -1,2 +1,3 @@
 node_modules
+bower_components
 *~

CONTRIBUTING.md

@@ -21,6 +21,7 @@ You can now run the following grunt tasks:
 * `grunt check` will run [JSHint](http://www.jshint.com/) on your code (do this before submitting a pull request) to catch errors
 * `grunt develop` will create a single file version of the library for testing in `dist/idbfs.js`
 * `grunt release` like `develop` but will also create a minified version of the library in `dist/idbfs.min.js`
+* `grunt test` will run [JSHint](http://www.jshint.com/) on your code and the test suite in [PhantomJS](http://phantomjs.org/)
 
 Once you've done some hacking and you'd like to have your work merged, you'll need to
 make a pull request. If you're patch includes code, make sure to check that all the
@@ -29,11 +30,27 @@ to the `AUTHORS` file.
 
 ## Tests
 
-Tests are writting using [Jasmine](http://pivotal.github.io/jasmine/). You can run the tests
-in your browser by opening the `tests` directory. You can also run them
-[here](http://js-platform.github.io/idbfs/tests/).
+Tests are writting using [Mocha](http://visionmedia.github.io/mocha/) and [Chai](http://chaijs.com/api/bdd/).
+You can run the tests in your browser by opening the `tests` directory. You can also run them
+[here](http://js-platform.github.io/filer/tests/).
+
+There are a number of configurable options for the test suite, which are set via query string params.
+First, you can choose which filer source to use (i.e., src/, dist/filer.js or dist/filer.min.js).
+The default is to use what is in /src, and you can switch to built versions like so:
+* tests/index.html?filer-dist/filer.js
+* tests/index.html?filer-dist/filer.min.js
+
+Second, you can specify which provider to use for all non-provider specific tests (i.e., most of the tests).
+The default provider is `Memory`, and you can switch it like so:
+* tests/index.html?filer-provider=memory
+* tests/index.html?filer-provider=indexeddb
+* tests/index.html?filer-provider=websql
+
+If you're writing tests, make sure you write them in the same style as existing tests, which are
+provider agnostic. See `tests/lib/test-utils.js` and how it gets used in various tests as
+an example.
 
 ## Communication
 
 If you'd like to talk to someone about the project, you can reach us on irc.mozilla.org in the
-mofodev channel. Look for "ack" or "humph".
+#filer or #mofodev channel. Look for "ack" or "humph".

README.md

@@ -73,13 +73,14 @@ object can specify a number of optional arguments, including:
 * `provider`: an explicit storage provider to use for the file system's database context provider. See the section on [Storage Providers](#providers).
 
 The `callback` function indicates when the file system is ready for use. Depending on the storage provider used, this might
-be right away, or could take some time. The callback should expect an `error` argument, which will be null if everything worked.
-Also users should check the file system's `readyState` and `error` properties to make sure it is usable.
+be right away, or could take some time. The callback should expect two arguments: first, an `error` argument, which will be
+null if everything worked; second, an instance, such that you can access the newly ready FileSystem instance. Also users
+should check the file system's `readyState` and `error` properties to make sure it is usable.
 
 ```javascript
 var fs;
 
-function fsReady(err) {
+function fsReady(err, fs) {
   if(err) throw err;
   // Safe to use fs now...
 }

bower.json

@@ -0,0 +1,19 @@
+{
+  "name": "filer",
+  "version": "0.0.4",
+  "main": "dist/filer.js",
+  "devDependencies": {
+    "mocha": "1.17.1",
+    "chai": "1.9.0"
+  },
+  "ignore": [
+    "build",
+    "examples",
+    "package.json",
+    "tests",
+    "gruntfile.js",
+    "node_modules",
+    "src",
+    "tools"
+  ]
+}

gruntfile.js

@@ -28,6 +28,15 @@ module.exports = function(grunt) {
            ]
     },
 
+    mocha: {
+      test: {
+        src: 'tests/index.html',
+        options: {
+          log: true
+        }
+      }
+    },
+
     requirejs: {
       develop: {
         options: {
@@ -60,10 +69,12 @@ module.exports = function(grunt) {
   grunt.loadNpmTasks('grunt-contrib-uglify');
   grunt.loadNpmTasks('grunt-contrib-requirejs');
   grunt.loadNpmTasks('grunt-contrib-jshint');
+  grunt.loadNpmTasks('grunt-mocha');
 
   grunt.registerTask('develop', ['clean', 'requirejs']);
   grunt.registerTask('release', ['develop', 'uglify']);
   grunt.registerTask('check', ['jshint']);
+  grunt.registerTask('test', ['check', 'mocha']);
 
   grunt.registerTask('default', ['develop']);
 };

package.json

@@ -7,11 +7,15 @@
   "homepage": "http://js-platform.github.io/filer",
   "bugs": "https://github.com/js-platform/filer/issues",
   "license": "BSD",
+  "scripts": {
+    "postinstall": "./node_modules/.bin/bower install"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/js-platform/filer.git"
   },
   "devDependencies": {
+    "bower": "~1.0.0",
     "grunt": "~0.4.0",
     "grunt-contrib-clean": "~0.4.0",
     "grunt-contrib-requirejs": "~0.4.0",
@@ -19,8 +23,8 @@
     "grunt-contrib-watch": "~0.3.1",
     "grunt-contrib-compress": "~0.4.1",
     "grunt-contrib-connect": "~0.1.2",
-    "grunt-contrib-jasmine": "~0.3.3",
     "grunt-contrib-concat": "~0.1.3",
-    "grunt-contrib-jshint": "~0.7.1"
+    "grunt-contrib-jshint": "~0.7.1",
+    "grunt-mocha": "0.4.10"
   }
 }

src/fs.js

@@ -1429,7 +1429,7 @@ define(function(require) {
           fs.readyState = FS_READY;
           runQueued();
         }
-        callback(error);
+        callback(error, fs);
       }
 
       if(err) {

src/providers/memory.js

@@ -1,36 +1,69 @@
 define(function(require) {
   var FILE_SYSTEM_NAME = require('src/constants').FILE_SYSTEM_NAME;
 
+  // Based on https://github.com/caolan/async/blob/master/lib/async.js
+  var nextTick = (function() {
+    if (typeof process === 'undefined' || !(process.nextTick)) {
+      if (typeof setImmediate === 'function') {
+        return function (fn) {
+          // not a direct alias for IE10 compatibility
+          setImmediate(fn);
+        };
+      } else {
+        return function (fn) {
+          setTimeout(fn, 0);
+        };
+      }
+    }
+    return process.nextTick;
+  }());
+
+  function asyncCallback(callback) {
+    nextTick(callback);
+  }
+
   function MemoryContext(db, readOnly) {
     this.readOnly = readOnly;
     this.objectStore = db;
   }
   MemoryContext.prototype.clear = function(callback) {
     if(this.readOnly) {
-      return callback("[MemoryContext] Error: write operation on read only context");
+      asyncCallback(function() {
+        callback("[MemoryContext] Error: write operation on read only context");
+      });
+      return;
     }
     var objectStore = this.objectStore;
     Object.keys(objectStore).forEach(function(key){
       delete objectStore[key];
     });
-    callback(null);
+    asyncCallback(callback);
   };
   MemoryContext.prototype.get = function(key, callback) {
-    callback(null, this.objectStore[key]);
+    var that = this;
+    asyncCallback(function() {
+      callback(null, that.objectStore[key]);
+    });
   };
   MemoryContext.prototype.put = function(key, value, callback) {
     if(this.readOnly) {
-      return callback("[MemoryContext] Error: write operation on read only context");
+      asyncCallback(function() {
+        callback("[MemoryContext] Error: write operation on read only context");
+      });
+      return;
     }
     this.objectStore[key] = value;
-    callback(null);
+    asyncCallback(callback);
   };
   MemoryContext.prototype.delete = function(key, callback) {
     if(this.readOnly) {
-      return callback("[MemoryContext] Error: write operation on read only context");
+      asyncCallback(function() {
+        callback("[MemoryContext] Error: write operation on read only context");
+      });
+      return;
     }
     delete this.objectStore[key];
-    callback(null);
+    asyncCallback(callback);
   };
 
 
@@ -43,7 +76,9 @@ define(function(require) {
   };
 
   Memory.prototype.open = function(callback) {
-    callback(null, true);
+    asyncCallback(function() {
+      callback(null, true);
+    });
   };
   Memory.prototype.getReadOnlyContext = function() {
     return new MemoryContext(this.db, true);

tests/bugs/issue105.js

@@ -0,0 +1,35 @@
+define(["Filer", "util"], function(Filer, util) {
+
+ describe('trailing slashes in path names, issue 105', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should deal with trailing slashes properly, path == path/', function(done) {
+      var fs = util.fs();
+
+      fs.mkdir('/tmp', function(err) {
+        if(err) throw err;
+
+        fs.mkdir('/tmp/foo', function(err) {
+          if(err) throw err;
+
+          // Without trailing slash
+          fs.readdir('/tmp', function(err, result1) {
+            if(err) throw err;
+            expect(result1).to.exist;
+            expect(result1.length).to.equal(1);
+
+            // With trailing slash
+            fs.readdir('/tmp/', function(err, result2) {
+              if(err) throw err;
+              expect(result2).to.exist;
+              expect(result2[0]).to.equal('tmp');
+              expect(result1).to.deep.equal(result2);
+              done();
+            });
+          });
+        });
+      });
+    });
+  });
+});

tests/bugs/issue106.js

@@ -0,0 +1,31 @@
+define(["Filer", "util"], function(Filer, util) {
+
+  describe('fs.writeFile truncation - issue 106', function() {
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
+
+    it('should truncate an existing file', function(done) {
+      var fs = util.fs();
+      var filename = '/test';
+
+      fs.writeFile(filename, '1', function(err) {
+        if(err) throw err;
+
+        fs.stat(filename, function(err, stats) {
+          if(err) throw err;
+          expect(stats.size).to.equal(1);
+
+          fs.writeFile(filename, '', function(err) {
+            if(err) throw err;
+
+            fs.stat(filename, function(err, stats) {
+              if(err) throw err;
+              expect(stats.size).to.equal(0);
+              done();
+            });
+          });
+        });
+      });
+    });
+  });
+});

tests/common.js

@@ -1,39 +0,0 @@
-var TEST_DATABASE_NAME = '__test';
-var DEFAULT_TIMEOUT = 5000;
-
-var test_database_names = [];
-window.onbeforeunload = function() {
-  test_database_names.forEach(function(name) {
-    indexedDB.deleteDatabase(name);
-  });
-};
-
-function mk_id(length) {
-  var text = '';
-  var tokens = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-
-  for( var i=0; i < length; i++ )
-      text += tokens.charAt(Math.floor(Math.random() * tokens.length));
-
-  return text;
-};
-
-function mk_db_name() {
-  var name = TEST_DATABASE_NAME + mk_id(5) + Date.now();
-  test_database_names.push(name);
-  return name;
-};
-
-function typed_array_equal(left, right) {
-  if(left.length !== right.length) {
-    return false;
-  }
-
-  for(var i = 0; i < left.length; ++ i) {
-    if(left[i] !== right[i]) {
-      return false;
-    }
-  }
-
-  return true;
-};

tests/index.html

@@ -1,16 +1,33 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <head>
-  <title>Jasmine Spec Runner</title>
+  <meta charset="utf-8">
+  <title>Mocha Tests</title>
+  <link rel="stylesheet" href="../bower_components/mocha/mocha.css" />
+  <script src="../bower_components/chai/chai.js"></script>
+  <script src="../bower_components/mocha/mocha.js"></script>
+  <script>
+    // Polyfill for function.bind, which PhantomJS seems to need, see
+    // https://gist.github.com/Daniel-Hug/5682738/raw/147ec7d72123fbef4d7471dcc88c2bc3d52de8d9/function-bind.js
+    Function.prototype.bind = (function () {}).bind || function (b) {
+      if (typeof this !== "function") {
+      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
+      }
 
-  <link rel="shortcut icon" type="image/png" href="../tools/jasmine-1.3.1/jasmine_favicon.png">
-  <link rel="stylesheet" type="text/css" href="../tools/jasmine-1.3.1/jasmine.css">
-  <script type="text/javascript" src="../tools/jasmine-1.3.1/jasmine.js"></script>
-  <script type="text/javascript" src="../tools/jasmine-1.3.1/jasmine-html.js"></script>
-  <script type="text/javascript" src="common.js"></script>
+      function c() {}
+      var a = [].slice,
+          f = a.call(arguments, 1),
+          e = this,
+          d = function () {
+              return e.apply(this instanceof c ? this : b || window, f.concat(a.call(arguments)));
+          };
+      c.prototype = this.prototype;
+      d.prototype = new c();
+      return d;
+    };
+  </script>
   <script src="../lib/require.js" data-main="require-config"></script>
-</head>
+ </head>
 <body>
+  <div id="mocha"></div>
 </body>
 </html>

tests/lib/indexeddb.js

@@ -0,0 +1,53 @@
+define(["Filer"], function(Filer) {
+
+  var indexedDB = window.indexedDB       ||
+                  window.mozIndexedDB    ||
+                  window.webkitIndexedDB ||
+                  window.msIndexedDB;
+
+  var needsCleanup = [];
+  window.addEventListener('beforeunload', function() {
+    needsCleanup.forEach(function(f) { f(); });
+  });
+
+  function IndexedDBTestProvider(name) {
+    var _done = false;
+    var that = this;
+
+    function cleanup(callback) {
+      if(!that.provider || _done) {
+        return;
+      }
+
+      // We have to force any other connections to close
+      // before we can delete a db.
+      if(that.provider.db) {
+        that.provider.db.close();
+      }
+
+      callback = callback || function(){};
+      var request = indexedDB.deleteDatabase(name);
+      function finished() {
+        that.provider = null;
+        _done = true;
+        callback();
+      }
+      request.onsuccess = finished;
+      request.onerror = finished;
+    }
+
+    function init() {
+      if(that.provider) {
+        return;
+      }
+      that.provider = new Filer.FileSystem.providers.IndexedDB(name);
+      needsCleanup.push(cleanup);
+    }
+
+    this.init = init;
+    this.cleanup = cleanup;
+  }
+
+  return IndexedDBTestProvider;
+
+});

tests/lib/memory.js

@@ -0,0 +1,24 @@
+define(["Filer"], function(Filer) {
+
+  function MemoryTestProvider(name) {
+    var that = this;
+
+    function cleanup(callback) {
+      that.provider = null;
+      callback();
+    }
+
+    function init() {
+      if(that.provider) {
+        return;
+      }
+      that.provider = new Filer.FileSystem.providers.Memory(name);
+    }
+
+    this.init = init;
+    this.cleanup = cleanup;
+  }
+
+  return MemoryTestProvider;
+
+});

tests/lib/test-utils.js

@@ -0,0 +1,95 @@
+define(["Filer", "tests/lib/indexeddb", "tests/lib/websql", "tests/lib/memory"],
+function(Filer, IndexedDBTestProvider, WebSQLTestProvider, MemoryTestProvider) {
+
+  var _provider;
+  var _fs;
+
+  function uniqueName() {
+    if(!uniqueName.seed) {
+      uniqueName.seed = Date.now();
+    }
+    return 'filer-testdb-' + uniqueName.seed++;
+  }
+
+  function setup(callback) {
+    // We support specifying the provider via the query string
+    // (e.g., ?filer-provider=IndexedDB). If not specified, we use
+    // the Memory provider by default.  See test/require-config.js
+    // for definition of window.filerArgs.
+    var providerType = window.filerArgs && window.filerArgs.provider ?
+      window.filerArgs.provider : 'Memory';
+
+    var name = uniqueName();
+
+    switch(providerType.toLowerCase()) {
+      case 'indexeddb':
+        _provider = new IndexedDBTestProvider(name);
+        break;
+      case 'websql':
+        _provider = new WebSQLTestProvider(name);
+        break;
+      case 'memory':
+      /* falls through */
+      default:
+        _provider = new MemoryTestProvider(name);
+        break;
+    }
+
+    // Allow passing FS flags on query string
+    var flags = window.filerArgs && window.filerArgs.flags ?
+      window.filerArgs.flags : 'FORMAT';
+
+    // Create a file system and wait for it to get setup
+    _provider.init();
+
+    function complete(err, fs) {
+      if(err) throw err;
+      _fs = fs;
+      callback();
+    }
+    return new Filer.FileSystem({
+      name: name,
+      provider: _provider.provider,
+      flags: flags
+    }, complete);
+  }
+
+  function fs() {
+    if(!_fs) {
+      throw "TestUtil: call setup() before fs()";
+    }
+    return _fs;
+  }
+
+  function provider() {
+    if(!_provider) {
+      throw "TestUtil: call setup() before provider()";
+    }
+    return _provider;
+  }
+
+  function cleanup(callback) {
+    if(!_provider) {
+      return;
+    }
+    _provider.cleanup(function() {
+      _provider = null;
+      _fs = null;
+      callback();
+    });
+  }
+
+  return {
+    uniqueName: uniqueName,
+    setup: setup,
+    fs: fs,
+    provider: provider,
+    providers: {
+      IndexedDB: IndexedDBTestProvider,
+      WebSQL: WebSQLTestProvider,
+      Memory: MemoryTestProvider
+    },
+    cleanup: cleanup
+  };
+
+});

tests/lib/websql.js

@@ -0,0 +1,43 @@
+define(["Filer"], function(Filer) {
+
+  var needsCleanup = [];
+  window.addEventListener('beforeunload', function() {
+    needsCleanup.forEach(function(f) { f(); });
+  });
+
+  function WebSQLTestProvider(name) {
+    var _done = false;
+    var that = this;
+
+    function cleanup(callback) {
+      if(!that.provider || _done) {
+        return;
+      }
+      // Provider is there, but db was never touched
+      if(!that.provider.db) {
+        return;
+      }
+
+      var context = that.provider.getReadWriteContext();
+      context.clear(function() {
+        that.provider = null;
+        _done = true;
+        callback();
+      });
+    }
+
+    function init() {
+      if(that.provider) {
+        return;
+      }
+      that.provider = new Filer.FileSystem.providers.WebSQL(name);
+      needsCleanup.push(cleanup);
+    }
+
+    this.init = init;
+    this.cleanup = cleanup;
+  }
+
+  return WebSQLTestProvider;
+
+});

tests/require-config.js

@@ -1,48 +1,89 @@
 /**
- * Assembles fs.js at runtime in the browswer, as well as all test
- * spec files.  Add spec files to the list in test-manifest.js
+ * Add spec files to the list in test-manifest.js
  */
 
-require.config({
-  paths: {
-    "tests": "../tests",
-    "src": "../src",
-    "spec": "../tests/spec",
-    "Filer": "../src/index"
-  },
-  baseUrl: "../lib",
-  optimize: "none",
-  shim: {
-    // TextEncoder and TextDecoder shims. encoding-indexes must get loaded first,
-    // and we use a fake one for reduced size, since we only care about utf8.
-    "encoding": {
-      deps: ["encoding-indexes-shim"]
+// Dynamically figure out which source to use (dist/ or src/) based on
+// query string:
+//
+// ?filer-dist/filer.js     --> use dist/filer.js
+// ?filer-dist/filer.min.js --> use dist/filer.min.js
+// ?<default>               --> (default) use src/filer.js with require
+var filerArgs = window.filerArgs = {};
+var config = (function() {
+  var query = window.location.search.substring(1);
+  query.split('&').forEach(function(pair) {
+    pair = pair.split('=');
+    var key = decodeURIComponent(pair[0]);
+    var value = decodeURIComponent(pair[1]);
+    if(key.indexOf('filer-') === 0) {
+      filerArgs[ key.replace(/^filer-/, '') ] = value;
     }
+  });
+
+  // Support dist/filer.js
+  if(filerArgs['filer-dist/filer.js']) {
+    return {
+      paths: {
+        "tests": "../tests",
+        "spec": "../tests/spec",
+        "bugs": "../tests/bugs",
+        "util": "../tests/lib/test-utils",
+        "Filer": "../dist/filer"
+      },
+      baseUrl: "../lib",
+      optimize: "none"
+    };
   }
-});
+
+  // Support dist/filer.min.js
+  if(filerArgs['filer-dist/filer.min.js']) {
+    return {
+      paths: {
+        "tests": "../tests",
+        "spec": "../tests/spec",
+        "bugs": "../tests/bugs",
+        "util": "../tests/lib/test-utils",
+        "Filer": "../dist/filer.min"
+      },
+      baseUrl: "../lib",
+      optimize: "none"
+    };
+  }
+
+  // Support src/ filer via require
+  return {
+    paths: {
+      "tests": "../tests",
+      "src": "../src",
+      "spec": "../tests/spec",
+      "bugs": "../tests/bugs",
+      "util": "../tests/lib/test-utils",
+      "Filer": "../src/index"
+    },
+    baseUrl: "../lib",
+    optimize: "none",
+    shim: {
+      // TextEncoder and TextDecoder shims. encoding-indexes must get loaded first,
+      // and we use a fake one for reduced size, since we only care about utf8.
+      "encoding": {
+        deps: ["encoding-indexes-shim"]
+      }
+    }
+  };
+}());
+
+require.config(config);
+
+// Intentional globals
+assert = chai.assert;
+expect = chai.expect;
+
+// We need to setup describe() support before loading tests
+mocha.setup("bdd");
 
 require(["tests/test-manifest"], function() {
-  var jasmineEnv = jasmine.getEnv();
-  jasmineEnv.updateInterval = 1000;
-
-  var htmlReporter = new jasmine.HtmlReporter();
-
-  jasmineEnv.addReporter(htmlReporter);
-
-  jasmineEnv.specFilter = function(spec) {
-    return htmlReporter.specFilter(spec);
-  };
-
-  var currentWindowOnload = window.onload;
-
   window.onload = function() {
-    if (currentWindowOnload) {
-      currentWindowOnload();
-    }
-    execJasmine();
+    mocha.checkLeaks();
+    mocha.run();
   };
-
-  function execJasmine() {
-    jasmineEnv.execute();
-  }
 });

tests/spec/adapters/adapters.general.spec.js

@@ -1,9 +1,9 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   // We reuse the same set of tests for all adapters.
   // buildTestsFor() creates a set of tests bound to an
-  // adapter, and uses a Memory() provider internally.
-
+  // adapter, and uses the provider set on the query string
+  // (defaults to Memory, see test-utils.js).
   function buildTestsFor(adapterName, buildAdapter) {
     function encode(str) {
       // TextEncoder is either native, or shimmed by Filer
@@ -16,187 +16,133 @@ define(["Filer"], function(Filer) {
     var value2Str = "value2", value2Buffer = encode(value2Str);
 
     function createProvider() {
-      var memoryProvider = new Filer.FileSystem.providers.Memory();
-      return buildAdapter(memoryProvider);
+      return buildAdapter(util.provider().provider);
     }
 
     describe("Filer.FileSystem.adapters." + adapterName, function() {
+      beforeEach(util.setup);
+      afterEach(util.cleanup);
+
       it("is supported -- if it isn't, none of these tests can run.", function() {
-        // Allow for combined adapters (e.g., 'AES+Zlib') joined by '+'
+        // Allow for combined adapters (e.g., 'Encryption+Compression') joined by '+'
         adapterName.split('+').forEach(function(name) {
-          expect(Filer.FileSystem.adapters[name].isSupported()).toEqual(true);
+          expect(Filer.FileSystem.adapters[name].isSupported()).to.be.true;
         });
       });
 
       it("has open, getReadOnlyContext, and getReadWriteContext instance methods", function() {
         var provider = createProvider();
-        expect(typeof provider.open).toEqual('function');
-        expect(typeof provider.getReadOnlyContext).toEqual('function');
-        expect(typeof provider.getReadWriteContext).toEqual('function');
+        expect(provider.open).to.be.a('function');
+        expect(provider.getReadOnlyContext).to.be.a('function');
+        expect(provider.getReadWriteContext).to.be.a('function');
       });
+    });
 
-      describe("open a Memory provider with an " + adapterName + " adapter", function() {
-        it("should open a new database", function() {
-          var complete = false;
-          var _error, _result;
+    describe("open a Memory provider with an " + adapterName + " adapter", function() {
+      beforeEach(util.setup);
+      afterEach(util.cleanup);
 
-          var provider = createProvider();
-          provider.open(function(err, firstAccess) {
-            _error = err;
-            _result = firstAccess;
-            complete = true;
-          });
+      it("should open a new database", function(done) {
+        var provider = createProvider();
+        provider.open(function(error, firstAccess) {
+          expect(error).not.to.exist;
+          expect(firstAccess).to.be.true;
+          done();
+        });
+      });
+    });
 
-          waitsFor(function() {
-            return complete;
-          }, 'test to complete', DEFAULT_TIMEOUT);
+    describe("Read/Write operations on a Memory provider with an " + adapterName + " adapter", function() {
+      beforeEach(util.setup);
+      afterEach(util.cleanup);
 
-          runs(function() {
-            expect(_error).toEqual(null);
-            expect(_result).toEqual(true);
+      it("should allow put() and get()", function(done) {
+        var provider = createProvider();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
+
+          var context = provider.getReadWriteContext();
+          context.put("key", valueBuffer, function(error, result) {
+            if(error) throw error;
+
+            context.get("key", function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.deep.equal(valueBuffer);
+              done();
+            });
           });
         });
       });
 
-      describe("Read/Write operations on a Memory provider with an " + adapterName + " adapter", function() {
-        it("should allow put() and get()", function() {
-          var complete = false;
-          var _error, _result;
+      it("should allow delete()", function(done) {
+        var provider = createProvider();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
-          var provider = createProvider();
-          provider.open(function(err, firstAccess) {
-            _error = err;
+          var context = provider.getReadWriteContext();
+          context.put("key", valueBuffer, function(error, result) {
+            if(error) throw error;
 
-            var context = provider.getReadWriteContext();
-            context.put("key", valueBuffer, function(err, result) {
-              _error = _error || err;
-              context.get("key", function(err, result) {
-                _error = _error || err;
-                _result = result;
+            context.delete("key", function(error, result) {
+              if(error) throw error;
 
-                complete = true;
+              context.get("key", function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).not.to.exist;
+                done();
               });
             });
           });
-
-          waitsFor(function() {
-            return complete;
-          }, 'test to complete', DEFAULT_TIMEOUT);
-
-          runs(function() {
-            expect(_error).toEqual(null);
-            expect(_result).toEqual(valueBuffer);
-          });
         });
+      });
 
-        it("should allow delete()", function() {
-          var complete = false;
-          var _error, _result;
+      it("should allow clear()", function(done) {
+        var provider = createProvider();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
-          var provider = createProvider();
-          provider.open(function(err, firstAccess) {
-            _error = err;
+          var context = provider.getReadWriteContext();
+          context.put("key1", value1Buffer, function(error, result) {
+            if(error) throw error;
 
-            var context = provider.getReadWriteContext();
-            context.put("key", valueBuffer, function(err, result) {
-              _error = _error || err;
-              context.delete("key", function(err, result) {
-                _error = _error || err;
-                context.get("key", function(err, result) {
-                  _error = _error || err;
-                  _result = result;
+            context.put("key2", value2Buffer, function(error, result) {
+              if(error) throw error;
 
-                  complete = true;
-                });
-              });
-            });
-          });
+              context.clear(function(err) {
+                if(error) throw error;
 
-          waitsFor(function() {
-            return complete;
-          }, 'test to complete', DEFAULT_TIMEOUT);
+                context.get("key1", function(error, result) {
+                  if(error) throw error;
+                  expect(result).not.to.exist;
 
-          runs(function() {
-            expect(_error).toEqual(null);
-            expect(_result).toEqual(null);
-          });
-        });
-
-        it("should allow clear()", function() {
-          var complete = false;
-          var _error, _result1, _result2;
-
-          var provider = createProvider();
-          provider.open(function(err, firstAccess) {
-            _error = err;
-
-            var context = provider.getReadWriteContext();
-            context.put("key1", value1Buffer, function(err, result) {
-              _error = _error || err;
-              context.put("key2", value2Buffer, function(err, result) {
-                _error = _error || err;
-
-                context.clear(function(err) {
-                  _error = _error || err;
-
-                  context.get("key1", function(err, result) {
-                    _error = _error || err;
-                    _result1 = result;
-
-                    context.get("key2", function(err, result) {
-                      _error = _error || err;
-                      _result2 = result;
-
-                      complete = true;
-                    });
+                  context.get("key2", function(error, result) {
+                    expect(error).not.to.exist;
+                    expect(result).not.to.exist;
+                      done();
                   });
                 });
               });
             });
           });
-
-          waitsFor(function() {
-            return complete;
-          }, 'test to complete', DEFAULT_TIMEOUT);
-
-          runs(function() {
-            expect(_error).toEqual(null);
-            expect(_result1).toEqual(null);
-            expect(_result2).toEqual(null);
-          });
         });
+      });
 
-        it("should fail when trying to write on ReadOnlyContext", function() {
-          var complete = false;
-          var _error, _result;
+      it("should fail when trying to write on ReadOnlyContext", function(done) {
+        var provider = createProvider();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
-          var provider = createProvider();
-          provider.open(function(err, firstAccess) {
-            _error = err;
-
-            var context = provider.getReadOnlyContext();
-            context.put("key1", value1Buffer, function(err, result) {
-              _error = _error || err;
-              _result = result;
-
-              complete = true;
-            });
-          });
-
-          waitsFor(function() {
-            return complete;
-          }, 'test to complete', DEFAULT_TIMEOUT);
-
-          runs(function() {
-            expect(_error).toBeDefined();
-            expect(_result).toEqual(null);
+          var context = provider.getReadOnlyContext();
+          context.put("key1", value1Buffer, function(error, result) {
+            expect(error).to.exist;
+            expect(result).not.to.exist;
+            done();
           });
         });
       });
     });
   }
 
-
   // Encryption
   buildTestsFor('Encryption', function buildAdapter(provider) {
     var passphrase = '' + Date.now();

tests/spec/adapters/adapters.spec.js

@@ -1,15 +1,15 @@
 define(["Filer"], function(Filer) {
   describe("Filer.FileSystem.adapters", function() {
     it("is defined", function() {
-      expect(typeof Filer.FileSystem.adapters).not.toEqual(undefined);
+      expect(Filer.FileSystem.adapters).to.exist;
     });
 
     it("has a default Encryption constructor", function() {
-      expect(typeof Filer.FileSystem.adapters.Encryption).toEqual('function');
+      expect(Filer.FileSystem.adapters.Encryption).to.be.a('function');
     });
 
     it("has a default Compression constructor", function() {
-      expect(typeof Filer.FileSystem.adapters.Compression).toEqual('function');
+      expect(Filer.FileSystem.adapters.Compression).to.be.a('function');
     });
   });
 });

tests/spec/filer.spec.js

@@ -2,11 +2,11 @@ define(["Filer"], function(Filer) {
 
   describe("Filer", function() {
     it("is defined", function() {
-      expect(typeof Filer).not.toEqual(undefined);
+      expect(typeof Filer).not.to.equal(undefined);
     });
 
     it("has FileSystem constructor", function() {
-      expect(typeof Filer.FileSystem).toEqual('function');
+      expect(typeof Filer.FileSystem).to.equal('function');
     });
   });
 

tests/spec/fs.appendFile.spec.js

@@ -1,111 +1,72 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.appendFile', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-      this.fs.writeFile('/myfile', "This is a file.", { encoding: 'utf8' }, function(error) {
-        if(error) throw error;
+    beforeEach(function(done) {
+      util.setup(function() {
+        var fs = util.fs();
+        fs.writeFile('/myfile', "This is a file.", { encoding: 'utf8' }, function(error) {
+          if(error) throw error;
+          done();
+        });
       });
     });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.appendFile).toEqual('function');
+      var fs = util.fs();
+      expect(fs.appendFile).to.be.a('function');
     });
 
-    it('should append a utf8 file without specifying utf8 in appendFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should append a utf8 file without specifying utf8 in appendFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
       var more = " Appended.";
 
-      that.fs.appendFile('/myfile', more, function(error) {
+      fs.appendFile('/myfile', more, function(error) {
         if(error) throw error;
-      });
-      that.fs.readFile('/myfile', 'utf8', function(error, data) {
-        if(error) throw error;
-        _result = data;
-        complete = true;
-      });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents+more);
+        fs.readFile('/myfile', 'utf8', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents + more);
+          done();
+        });
       });
     });
 
-    it('should append a utf8 file with "utf8" option to appendFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should append a utf8 file with "utf8" option to appendFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
       var more = " Appended.";
 
-      that.fs.appendFile('/myfile', more, 'utf8', function(error) {
+      fs.appendFile('/myfile', more, 'utf8', function(error) {
         if(error) throw error;
-      });
-      that.fs.readFile('/myfile', 'utf8', function(error, data) {
-        if(error) throw error;
-        _result = data;
-        complete = true;
-      });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents+more);
+        fs.readFile('/myfile', 'utf8', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents + more);
+          done();
+        });
       });
     });
 
-    it('should append a utf8 file with {encoding: "utf8"} option to appendFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should append a utf8 file with {encoding: "utf8"} option to appendFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
       var more = " Appended.";
 
-      that.fs.appendFile('/myfile', more, { encoding: 'utf8' }, function(error) {
+      fs.appendFile('/myfile', more, { encoding: 'utf8' }, function(error) {
         if(error) throw error;
-      });
-      that.fs.readFile('/myfile', { encoding: 'utf8' }, function(error, data) {
-        if(error) throw error;
-        _result = data;
-        complete = true;
-      });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents+more);
+        fs.readFile('/myfile', { encoding: 'utf8' }, function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents + more);
+          done();
+        });
       });
     });
 
-    it('should append a binary file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should append a binary file', function(done) {
+      var fs = util.fs();
 
       // String and utf8 binary encoded versions of the same thing:
       var contents = "This is a file.";
@@ -115,56 +76,40 @@ define(["Filer"], function(Filer) {
       var binary3 = new Uint8Array([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46,
                                     32, 65, 112, 112, 101, 110, 100, 101, 100, 46]);
 
-      that.fs.writeFile('/mybinaryfile', binary, function(error) {
+      fs.writeFile('/mybinaryfile', binary, function(error) {
         if(error) throw error;
-      });
-      that.fs.appendFile('/mybinaryfile', binary2, function(error) {
-        if(error) throw error;
-      });
-      that.fs.readFile('/mybinaryfile', 'ascii', function(error, data) {
-        if(error) throw error;
-        _result = data;
-        complete = true;
-      });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
+        fs.appendFile('/mybinaryfile', binary2, function(error) {
+          if(error) throw error;
 
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(binary3);
+          fs.readFile('/mybinaryfile', 'ascii', function(error, data) {
+            expect(error).not.to.exist;
+            expect(data).to.deep.equal(binary3);
+            done();
+          });
+        });
       });
     });
 
-    it('should follow symbolic links', function () {
-      var complete = false;
-      var _result;
-      var that = this;
-
+    it('should follow symbolic links', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
       var more = " Appended.";
 
-      that.fs.symlink('/myfile', '/myFileLink', function (error) {
+      fs.symlink('/myfile', '/myFileLink', function (error) {
         if (error) throw error;
-      });
-      that.fs.appendFile('/myFileLink', more, 'utf8', function (error) {
-        if (error) throw error;
-      });
-      that.fs.readFile('/myFileLink', 'utf8', function(error, data) {
-        if(error) throw error;
-        _result = data;
-        complete = true;
-      });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
+        fs.appendFile('/myFileLink', more, 'utf8', function (error) {
+          if (error) throw error;
 
-      runs(function() {
-        expect(_result).toEqual(contents+more);
+          fs.readFile('/myFileLink', 'utf8', function(error, data) {
+            expect(error).not.to.exist;
+            expect(data).to.equal(contents + more);
+            done();
+          });
+        });
       });
     });
   });
 
-});
+});

tests/spec/fs.close.spec.js

@@ -1,50 +1,30 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.close', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.close).toEqual('function');
+      var fs = util.fs();
+      expect(typeof fs.close).to.equal('function');
     });
 
-    it('should release the file descriptor', function() {
-      var complete = false;
-      var _error;
-      var that = this;
-
+    it('should release the file descriptor', function(done) {
       var buffer = new Uint8Array(0);
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.close(fd, function(error) {
-          that.fs.read(fd, buffer, 0, buffer.length, undefined, function(error, result) {
-            _error = error;
-            complete = true;
+        fs.close(fd, function(error) {
+          fs.read(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+            expect(error).to.exist;
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-      });
     });
   });
 
-});
+});

tests/spec/fs.link.spec.js

@@ -1,102 +1,65 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.link', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.link).toEqual('function');
+      var fs = util.fs();
+      expect(fs.link).to.be.a('function');
     });
 
-    it('should create a link to an existing file', function() {
-      var complete = false;
-      var _error, _oldstats, _newstats;
-      var that = this;
+    it('should create a link to an existing file', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
 
-          that.fs.link('/myfile', '/myotherfile', function(error) {
+          fs.link('/myfile', '/myotherfile', function(error) {
             if(error) throw error;
 
-            that.fs.stat('/myfile', function(error, result) {
+            fs.stat('/myfile', function(error, result) {
               if(error) throw error;
 
-              _oldstats = result;
-              that.fs.stat('/myotherfile', function(error, result) {
-                if(error) throw error;
-
-                _newstats = result;
-
-                complete = true;
+              var _oldstats = result;
+              fs.stat('/myotherfile', function(error, result) {
+                expect(error).not.to.exist;
+                expect(result.nlinks).to.equal(2);
+                expect(result).to.deep.equal(_oldstats);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_newstats.node).toEqual(_oldstats.node);
-        expect(_newstats.nlinks).toEqual(2);
-        expect(_newstats).toEqual(_oldstats);
-      });
     });
 
-    it('should not follow symbolic links', function () {
-      var complete = false;
-      var _error, _oldstats, _linkstats, _newstats;
-      var that = this;
+    it('should not follow symbolic links', function(done) {
+      var fs = util.fs();
 
-      that.fs.stat('/', function (error, result) {
+      fs.stat('/', function (error, result) {
         if (error) throw error;
-        _oldstats = result;
-        that.fs.symlink('/', '/myfileLink', function (error) {
+        var _oldstats = result;
+        fs.symlink('/', '/myfileLink', function (error) {
           if (error) throw error;
-          that.fs.link('/myfileLink', '/myotherfile', function (error) {
+          fs.link('/myfileLink', '/myotherfile', function (error) {
             if (error) throw error;
-            that.fs.lstat('/myfileLink', function (error, result) {
+            fs.lstat('/myfileLink', function (error, result) {
               if (error) throw error;
-              _linkstats = result;
-              that.fs.lstat('/myotherfile', function (error, result) {
-                if (error) throw error;
-                _newstats = result;
-                complete = true;
+              var _linkstats = result;
+              fs.lstat('/myotherfile', function (error, result) {
+                expect(error).not.to.exist;
+                expect(result).to.deep.equal(_linkstats);
+                expect(result.nlinks).to.equal(2);
+                done();
               });
             });
           });
         });
       });
-
-     waitsFor(function () {
-       return complete;
-     }, 'test to complete', DEFAULT_TIMEOUT);
-
-     runs(function () {
-       expect(_error).toEqual(null);
-       expect(_newstats.node).toEqual(_linkstats.node);
-       expect(_newstats.node).toNotEqual(_oldstats.node);
-       expect(_newstats.nlinks).toEqual(2);
-       expect(_newstats).toEqual(_linkstats);
-     });
     });
   });
 

tests/spec/fs.lseek.spec.js

@@ -1,52 +1,39 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.lseek', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.lseek).toEqual('function');
+      var fs = util.fs();
+      expect(fs.lseek).to.be.a('function');
     });
 
-    it('should not follow symbolic links', function () {
-      var complete = false;
-      var _error, _stats;
-      var that = this;
+    it('should not follow symbolic links', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function (error, result) {
+      fs.open('/myfile', 'w', function (error, fd) {
         if (error) throw error;
 
-        var fd = result;
-        that.fs.close(fd, function (error) {
+        fs.close(fd, function (error) {
           if (error) throw error;
 
-          that.fs.symlink('/myfile', '/myFileLink', function (error) {
+          fs.symlink('/myfile', '/myFileLink', function (error) {
             if (error) throw error;
 
-            that.fs.rename('/myFileLink', '/myOtherFileLink', function (error) {
+            fs.rename('/myFileLink', '/myOtherFileLink', function (error) {
               if (error) throw error;
 
-              that.fs.stat('/myfile', function (error, result) {
-                _error1 = error;
+              fs.stat('/myfile', function (error, result) {
+                expect(error).not.to.exist;
 
-                that.fs.lstat('/myFileLink', function (error, result) {
-                  _error2 = error;
+                fs.lstat('/myFileLink', function (error, result) {
+                  expect(error).to.exist;
 
-                  that.fs.stat('/myOtherFileLink', function (error, result) {
+                  fs.stat('/myOtherFileLink', function (error, result) {
                     if (error) throw error;
-
-                    _stats = result;
-                    complete = true;
+                    expect(result.nlinks).to.equal(1);
+                    done();
                   });
                 });
               });
@@ -54,158 +41,116 @@ define(["Filer"], function(Filer) {
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error1).toEqual(null);
-        expect(_error2).toBeDefined();
-        expect(_stats.nlinks).toEqual(1);
-      });
     });
 
-    it('should set the current position if whence is SET', function() {
-      var complete = false;
-      var _error, _result, _stats;
-      var that = this;
-
+    it('should set the current position if whence is SET', function(done) {
+      var fs = util.fs();
       var offset = 3;
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var result_buffer = new Uint8Array(buffer.length + offset);
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
           if(error) throw error;
 
-          that.fs.lseek(fd, offset, 'SET', function(error, result) {
-            _error = error;
-            _result = result;
+          fs.lseek(fd, offset, 'SET', function(error, result) {
+            expect(error).not.to.exist;
+            expect(result).to.equal(offset);
 
-            that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+            fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
               if(error) throw error;
 
-              that.fs.read(fd, result_buffer, 0, result_buffer.length, 0, function(error, result) {
+              fs.read(fd, result_buffer, 0, result_buffer.length, 0, function(error, result) {
                 if(error) throw error;
 
-                that.fs.stat('/myfile', function(error, result) {
+                fs.stat('/myfile', function(error, result) {
                   if(error) throw error;
 
-                  _stats = result;
-
-                  complete = true;
+                  expect(result.size).to.equal(offset + buffer.length);
+                  var expected = new Uint8Array([1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8]);
+                  expect(result_buffer).to.deep.equal(expected);
+                  done();
                 });
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(offset);
-        expect(_stats.size).toEqual(offset + buffer.length);
-        var expected = new Uint8Array([1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8]);
-        expect(typed_array_equal(result_buffer, expected)).toEqual(true);
-      });
     });
 
-    it('should update the current position if whence is CUR', function() {
-      var complete = false;
-      var _error, _result, _stats;
-      var that = this;
-
+    it('should update the current position if whence is CUR', function(done) {
+      var fs = util.fs();
       var offset = -2;
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var result_buffer = new Uint8Array(2 * buffer.length + offset);
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
           if(error) throw error;
 
-          that.fs.lseek(fd, offset, 'CUR', function(error, result) {
-            _error = error;
-            _result = result;
+          fs.lseek(fd, offset, 'CUR', function(error, result) {
+            expect(error).not.to.exist;
+            expect(result).to.equal(offset + buffer.length);
 
-            that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+            fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
               if(error) throw error;
 
-              that.fs.read(fd, result_buffer, 0, result_buffer.length, 0, function(error, result) {
+              fs.read(fd, result_buffer, 0, result_buffer.length, 0, function(error, result) {
                 if(error) throw error;
 
-                that.fs.stat('/myfile', function(error, result) {
+                fs.stat('/myfile', function(error, result) {
                   if(error) throw error;
 
-                  _stats = result;
-
-                  complete = true;
+                  expect(result.size).to.equal(offset + 2 * buffer.length);
+                  var expected = new Uint8Array([1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8]);
+                  expect(result_buffer).to.deep.equal(expected);
+                  done();
                 });
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(offset + buffer.length);
-        expect(_stats.size).toEqual(offset + 2 * buffer.length);
-        var expected = new Uint8Array([1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 8]);
-        expect(typed_array_equal(result_buffer, expected)).toEqual(true);
-      });
     });
 
-    it('should update the current position if whence is END', function() {
-      var complete = false;
-      var _error, _result, _stats;
-      var that = this;
-
+    it('should update the current position if whence is END', function(done) {
+      var fs = util.fs();
       var offset = 5;
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var result_buffer;
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, result) {
         if(error) throw error;
 
         var fd1 = result;
-        that.fs.write(fd1, buffer, 0, buffer.length, undefined, function(error, result) {
+        fs.write(fd1, buffer, 0, buffer.length, undefined, function(error, result) {
           if(error) throw error;
 
-          that.fs.open('/myfile', 'w+', function(error, result) {
+          fs.open('/myfile', 'w+', function(error, result) {
             if(error) throw error;
 
             var fd2 = result;
-            that.fs.lseek(fd2, offset, 'END', function(error, result) {
-              _error = error;
-              _result = result;
+            fs.lseek(fd2, offset, 'END', function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.equal(offset + buffer.length);
 
-              that.fs.write(fd2, buffer, 0, buffer.length, undefined, function(error, result) {
+              fs.write(fd2, buffer, 0, buffer.length, undefined, function(error, result) {
                 if(error) throw error;
 
-                that.fs.stat('/myfile', function(error, result) {
+                fs.stat('/myfile', function(error, result) {
                   if(error) throw error;
 
-                  _stats = result;
-                  result_buffer = new Uint8Array(_stats.size);
-                  that.fs.read(fd2, result_buffer, 0, result_buffer.length, 0, function(error, result) {
+                  expect(result.size).to.equal(offset + 2 * buffer.length);
+                  result_buffer = new Uint8Array(result.size);
+                  fs.read(fd2, result_buffer, 0, result_buffer.length, 0, function(error, result) {
                     if(error) throw error;
-
-                    complete = true;
+                    var expected = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
+                    expect(result_buffer).to.deep.equal(expected);
+                    done();
                   });
                 });
               });
@@ -213,19 +158,7 @@ define(["Filer"], function(Filer) {
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(offset + buffer.length);
-        expect(_stats.size).toEqual(offset + 2 * buffer.length);
-        var expected = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8]);
-        expect(typed_array_equal(result_buffer, expected)).toEqual(true);
-      });
     });
   });
 
-});
+});

tests/spec/fs.lstat.spec.js

@@ -1,91 +1,49 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
  describe('fs.lstat', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.lstat).toEqual('function');
+      var fs = util.fs();
+      expect(typeof fs.lstat).to.equal('function');
     });
 
-    it('should return an error if path does not exist', function() {
-      var complete = false;
+    it('should return an error if path does not exist', function(done) {
+      var fs = util.fs();
       var _error, _result;
 
-      this.fs.lstat('/tmp', function(error, result) {
-        _error = error;
-        _result = result;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
+      fs.lstat('/tmp', function(error, result) {
+        expect(error).to.exist;
+        expect(result).not.to.exist;
+        done();
       });
     });
 
-    it('should return a stat object if path is not a symbolic link', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return a stat object if path is not a symbolic link', function(done) {
+      var fs = util.fs();
 
-      that.fs.lstat('/', function(error, result) {
-        _error = error;
-        _result = result;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toBeDefined();
+      fs.lstat('/', function(error, result) {
+        expect(error).not.to.exist;
+        expect(result).to.exist;
+        expect(result.type).to.equal('DIRECTORY');
+        done();
       });
     });
 
+    it('should return a stat object if path is a symbolic link', function(done) {
+      var fs = util.fs();
 
-    it('should return a stat object if path is a symbolic link', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
-      that.fs.symlink('/', '/mylink', function(error) {
+      fs.symlink('/', '/mylink', function(error) {
         if(error) throw error;
 
-        that.fs.lstat('/mylink', function(error, result) {
-          _error = error;
-          _result = result;
-
-          complete = true;
+        fs.lstat('/mylink', function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.exist;
+          expect(result.type).to.equal('SYMLINK');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toBeDefined();
-      });
     });
   });
 

tests/spec/fs.mkdir.spec.js

@@ -1,88 +1,46 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
  describe('fs.mkdir', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.mkdir).toEqual('function');
+      var fs = util.fs();
+      expect(fs.mkdir).to.be.a('function');
     });
 
-    it('should return an error if part of the parent path does not exist', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if part of the parent path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp/mydir', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'stat to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.mkdir('/tmp/mydir', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return an error if the path already exists', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path already exists', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.mkdir('/', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should make a new directory', function() {
-      var complete = false;
-      var _error, _result, _stat;
-      var that = this;
+    it('should make a new directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error, result) {
-        _error = error;
-        _result = result;
+      fs.mkdir('/tmp', function(error) {
+        expect(error).not.to.exist;
+        if(error) throw error;
 
-        that.fs.stat('/tmp', function(error, result) {
-          _stat = result;
-
-          complete = true;
+        fs.stat('/tmp', function(error, stats) {
+          expect(error).not.to.exist;
+          expect(stats).to.exist;
+          expect(stats.type).to.equal('DIRECTORY');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).not.toBeDefined();
-        expect(_stat).toBeDefined();
-      });
     });
   });
 

tests/spec/fs.open.spec.js

@@ -1,175 +1,93 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.open', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.open).toEqual('function');
+      var fs = util.fs();
+      expect(fs.open).to.be.a('function');
     });
 
-    it('should return an error if the parent path does not exist', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return an error if the parent path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/tmp/myfile', 'w+', function(error, result) {
-        _error = error;
-        _result = result;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
+      fs.open('/tmp/myfile', 'w+', function(error, result) {
+        expect(error).to.exist;
+        expect(result).not.to.exist;
+        done();
       });
     });
 
-    it('should return an error when flagged for read and the path does not exist', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return an error when flagged for read and the path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'r+', function(error, result) {
-        _error = error;
-        _result = result;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
+      fs.open('/myfile', 'r+', function(error, result) {
+        expect(error).to.exist;
+        expect(result).not.to.exist;
+        done();
       });
     });
 
 
-    it('should return an error when flagged for write and the path is a directory', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return an error when flagged for write and the path is a directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
+      fs.mkdir('/tmp', function(error) {
         if(error) throw error;
-        that.fs.open('/tmp', 'w', function(error, result) {
-          _error = error;
-          _result = result;
-
-          complete = true;
+        fs.open('/tmp', 'w', function(error, result) {
+          expect(error).to.exist;
+          expect(result).not.to.exist;
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
-      });
     });
 
-    it('should return an error when flagged for append and the path is a directory', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return an error when flagged for append and the path is a directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
+      fs.mkdir('/tmp', function(error) {
         if(error) throw error;
-        that.fs.open('/tmp', 'a', function(error, result) {
-          _error = error;
-          _result = result;
-
-          complete = true;
+        fs.open('/tmp', 'a', function(error, result) {
+          expect(error).to.exist;
+          expect(result).not.to.exist;
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
-      });
     });
 
-    it('should return a unique file descriptor', function() {
-      var complete1 = false;
-      var complete2 = false;
-      var _error, _result1, _result2;
-      var that = this;
+    it('should return a unique file descriptor', function(done) {
+      var fs = util.fs();
+      var fd1
 
-      that.fs.open('/file1', 'w+', function(error, fd) {
+      fs.open('/file1', 'w+', function(error, fd) {
         if(error) throw error;
-        _error = error;
-        _result1 = fd;
+        expect(error).not.to.exist;
+        expect(fd).to.be.a('number');
 
-        complete1 = true;
-      });
-      that.fs.open('/file2', 'w+', function(error, fd) {
-        if(error) throw error;
-        _error = error;
-        _result2 = fd;
-
-        complete2 = true;
-      });
-
-      waitsFor(function() {
-        return complete1 && complete2;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result1).toBeDefined();
-        expect(_result2).toBeDefined();
-        expect(_result1).not.toEqual(_result2);
-      });
-    });
-
-    it('should create a new file when flagged for write', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
-      that.fs.open('/myfile', 'w', function(error, result) {
-        if(error) throw error;
-        that.fs.stat('/myfile', function(error, result) {
-          _error = error;
-          _result = result;
-
-          complete = true;
+        fs.open('/file2', 'w+', function(error, fd) {
+          if(error) throw error;
+          expect(error).not.to.exist;
+          expect(fd).to.be.a('number');
+          expect(fd).not.to.equal(fd1);
+          done();
         });
       });
+    });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
+    it('should create a new file when flagged for write', function(done) {
+      var fs = util.fs();
 
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toBeDefined();
+      fs.open('/myfile', 'w', function(error, result) {
+        if(error) throw error;
+        fs.stat('/myfile', function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.exist;
+          expect(result.type).to.equal('FILE');
+          done();
+        });
       });
     });
   });
 
-});
+});

tests/spec/fs.read.spec.js

@@ -1,97 +1,61 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.read', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.read).toEqual('function');
+      var fs = util.fs();
+      expect(fs.read).to.be.a('function');
     });
 
-    it('should read data from a file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should read data from a file', function(done) {
+      var fs = util.fs();
       var wbuffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var rbuffer = new Uint8Array(wbuffer.length);
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
-
-        var fd = result;
-        that.fs.write(fd, wbuffer, 0, wbuffer.length, 0, function(error, result) {
+        fs.write(fd, wbuffer, 0, wbuffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.read(fd, rbuffer, 0, rbuffer.length, 0, function(error, result) {
-            _error = error;
-            _result = result;
-
-            complete = true;
+          fs.read(fd, rbuffer, 0, rbuffer.length, 0, function(error, result) {
+            expect(error).not.to.exist;
+            expect(result).to.equal(rbuffer.length);
+            expect(wbuffer).to.deep.equal(rbuffer);
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(rbuffer.length);
-        expect(typed_array_equal(wbuffer, rbuffer)).toEqual(true);
-      });
     });
 
-    it('should update the current file position', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should update the current file position', function(done) {
+      var fs = util.fs();
       var wbuffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var rbuffer = new Uint8Array(wbuffer.length);
-      _result = 0;
+      var _result = 0;
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.write(fd, wbuffer, 0, wbuffer.length, 0, function(error, result) {
+        fs.write(fd, wbuffer, 0, wbuffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.read(fd, rbuffer, 0, rbuffer.length / 2, undefined, function(error, result) {
+          fs.read(fd, rbuffer, 0, rbuffer.length / 2, undefined, function(error, result) {
             if(error) throw error;
 
             _result += result;
-            that.fs.read(fd, rbuffer, rbuffer.length / 2, rbuffer.length, undefined, function(error, result) {
+            fs.read(fd, rbuffer, rbuffer.length / 2, rbuffer.length, undefined, function(error, result) {
               if(error) throw error;
-
               _result += result;
-              complete = true;
+              expect(error).not.to.exist;
+              expect(_result).to.equal(rbuffer.length);
+              expect(wbuffer).to.deep.equal(rbuffer);
+              done();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(rbuffer.length);
-        expect(typed_array_equal(wbuffer.buffer, rbuffer.buffer)).toEqual(true);
-      });
     });
   });
 

tests/spec/fs.readdir.spec.js

@@ -1,95 +1,56 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
  describe('fs.readdir', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.readdir).toEqual('function');
+      var fs = util.fs();
+      expect(fs.readdir).to.be.a('function');
     });
 
-    it('should return an error if the path does not exist', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.readdir('/tmp/mydir', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.readdir('/tmp/mydir', function(error, files) {
+        expect(error).to.exist;
+        expect(files).not.to.exist;
+        done();
       });
     });
 
-    it('should return a list of files from an existing directory', function() {
-      var complete = false;
-      var _error, _files;
-      var that = this;
+    it('should return a list of files from an existing directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
-        that.fs.readdir('/', function(error, result) {
-          _error = error;
-          _files = result;
+      fs.mkdir('/tmp', function(error) {
+        if(error) throw error;
 
-          complete = true;
+        fs.readdir('/', function(error, files) {
+          expect(error).not.to.exist;
+          expect(files).to.exist;
+          expect(files.length).to.equal(1);
+          expect(files[0]).to.equal('tmp');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_files.length).toEqual(1);
-        expect(_files[0]).toEqual('tmp');
-      });
     });
 
-    it('should follow symbolic links', function() {
-      var complete = false;
-      var _error, _files;
-      var that = this;
+    it('should follow symbolic links', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
+      fs.mkdir('/tmp', function(error) {
         if(error) throw error;
-        that.fs.symlink('/', '/tmp/dirLink', function(error) {
+        fs.symlink('/', '/tmp/dirLink', function(error) {
           if(error) throw error;
-          that.fs.readdir('/tmp/dirLink', function(error, result) {
-            _error = error;
-            _files = result;
-
-            complete = true;
+          fs.readdir('/tmp/dirLink', function(error, files) {
+            expect(error).not.to.exist;
+            expect(files).to.exist;
+            expect(files.length).to.equal(1);
+            expect(files[0]).to.equal('tmp');
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_files.length).toEqual(1);
-        expect(_files[0]).toEqual('tmp');
-      });
     });
   });
 

tests/spec/fs.readlink.spec.js

@@ -1,86 +1,44 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.readlink', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.readlink).toEqual('function');
+      var fs = util.fs();
+      expect(fs.readlink).to.be.a('function');
     });
 
-    it('should return an error if part of the parent destination path does not exist', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if part of the parent destination path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.readlink('/tmp/mydir', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.readlink('/tmp/mydir', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return an error if the path is not a symbolic link', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path is not a symbolic link', function(done) {
+      var fs = util.fs();
 
-      that.fs.readlink('/', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.readlink('/', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return the contents of a symbolic link', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return the contents of a symbolic link', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/', '/myfile', function(error) {
+      fs.symlink('/', '/myfile', function(error) {
         if(error) throw error;
 
-        that.fs.readlink('/myfile', function(error, result) {
-          _error = error;
-          _result = result;
-          complete = true;
+        fs.readlink('/myfile', function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.equal('/');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual('/');
-       });
     });
   });
 

tests/spec/fs.rename.spec.js

@@ -1,62 +1,49 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.rename', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.rename).toEqual('function');
+      var fs = util.fs();
+      expect(fs.rename).to.be.a('function');
     });
 
-    it('should rename an existing file', function() {
+    it('should rename an existing file', function(done) {
       var complete1 = false;
       var complete2 = false;
-      var _error, _stats;
-      var that = this;
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      function maybeDone() {
+        if(complete1 && complete2) {
+          done();
+        }
+      }
+
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
 
-          that.fs.rename('/myfile', '/myotherfile', function(error) {
+          fs.rename('/myfile', '/myotherfile', function(error) {
             if(error) throw error;
 
-            that.fs.stat('/myfile', function(error, result) {
-              _error = error;
+            fs.stat('/myfile', function(error, result) {
+              expect(error).to.exist;
               complete1 = true;
+              maybeDone();
             });
 
-            that.fs.stat('/myotherfile', function(error, result) {
-              if(error) throw error;
-
-              _stats = result;
+            fs.stat('/myotherfile', function(error, result) {
+              expect(error).not.to.exist;
+              expect(result.nlinks).to.equal(1);
               complete2 = true;
+              maybeDone();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete1 && complete2;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_stats.nlinks).toEqual(1);
-      });
     });
   });
 

tests/spec/fs.rmdir.spec.js

@@ -1,161 +1,95 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
  describe('fs.rmdir', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.rmdir).toEqual('function');
+      var fs = util.fs();
+      expect(fs.rmdir).to.be.a('function');
     });
 
-    it('should return an error if the path does not exist', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.rmdir('/tmp/mydir', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.rmdir('/tmp/mydir', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return an error if attempting to remove the root directory', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if attempting to remove the root directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.rmdir('/', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.rmdir('/', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return an error if the directory is not empty', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the directory is not empty', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
-        that.fs.mkdir('/tmp/mydir', function(error) {
-          that.fs.rmdir('/', function(error) {
-            _error = error;
-
-            complete = true;
+      fs.mkdir('/tmp', function(error) {
+        if(error) throw error;
+        fs.mkdir('/tmp/mydir', function(error) {
+          if(error) throw error;
+          fs.rmdir('/', function(error) {
+            expect(error).to.exist;
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-      });
     });
 
-    it('should return an error if the path is not a directory', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path is not a directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
-        that.fs.open('/tmp/myfile', 'w', function(error, fd) {
-          that.fs.close(fd, function(error) {
-            that.fs.rmdir('/tmp/myfile', function(error) {
-              _error = error;
-
-              complete = true;
+      fs.mkdir('/tmp', function(error) {
+        if(error) throw error;
+        fs.open('/tmp/myfile', 'w', function(error, fd) {
+          if(error) throw error;
+          fs.close(fd, function(error) {
+            if(error) throw error;
+            fs.rmdir('/tmp/myfile', function(error) {
+              expect(error).to.exist;
+              done();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-      });
     });
 
-    it('should return an error if the path is a symbolic link', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the path is a symbolic link', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function (error) {
-        that.fs.symlink('/tmp', '/tmp/myfile', function (error) {
-          that.fs.rmdir('/tmp/myfile', function (error) {
-            _error = error;
-
-            complete = true;
+      fs.mkdir('/tmp', function (error) {
+        if(error) throw error;
+        fs.symlink('/tmp', '/tmp/myfile', function (error) {
+          if(error) throw error;
+          fs.rmdir('/tmp/myfile', function (error) {
+            expect(error).to.exist;
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-      });
     });
 
-    it('should remove an existing directory', function() {
-      var complete = false;
-      var _error, _stat;
-      var that = this;
+    it('should remove an existing directory', function(done) {
+      var fs = util.fs();
 
-      that.fs.mkdir('/tmp', function(error) {
-        that.fs.rmdir('/tmp', function(error) {
-          _error = error;
-          that.fs.stat('/tmp', function(error, result) {
-            _stat = result;
-
-            complete = true;
+      fs.mkdir('/tmp', function(error) {
+        if(error) throw error;
+        fs.rmdir('/tmp', function(error) {
+          expect(error).not.to.exist;
+          if(error) throw error;
+          fs.stat('/tmp', function(error, stats) {
+            expect(error).to.exist;
+            expect(stats).not.to.exist;
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_stat).not.toBeDefined();
-      });
     });
   });
 

tests/spec/fs.spec.js

@@ -1,39 +1,22 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe("fs", function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it("is an object", function() {
-      expect(typeof this.fs).toEqual('object');
+      var fs = util.fs();
+      expect(typeof fs).to.equal('object');
+      expect(fs).to.be.an.instanceof(Filer.FileSystem);
     });
 
-    it('should have a root directory', function() {
-      var complete = false;
-      var _result;
-
-      this.fs.stat('/', function(error, result) {
-        _result = result;
-
-        complete = true;
-    });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
+    it('should have a root directory', function(done) {
+      var fs = util.fs();
+      fs.stat('/', function(error, result) {
+        expect(error).not.to.exist;
+        expect(result).to.exist;
+        expect(result.type).to.equal('DIRECTORY');
+        done();
       });
     });
   });

tests/spec/fs.stat.spec.js

@@ -1,146 +1,93 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.stat', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.stat).toEqual('function');
+      var fs = util.fs();
+      expect(typeof fs.stat).to.equal('function');
     });
 
-    it('should return an error if path does not exist', function() {
-      var complete = false;
-      var _error, _result;
+    it('should return an error if path does not exist', function(done) {
+      var fs = util.fs();
 
-      this.fs.stat('/tmp', function(error, result) {
-        _error = error;
-        _result = result;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
+      fs.stat('/tmp', function(error, result) {
+        expect(error).to.exist;
+        expect(result).not.to.exist;
+        done();
       });
     });
 
-    it('should return a stat object if path exists', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return a stat object if path exists', function(done) {
+      var fs = util.fs();
 
-      that.fs.stat('/', function(error, result) {
-        _error = error;
-        _result = result;
+      fs.stat('/', function(error, result) {
+        expect(error).not.to.exist;
+        expect(result).to.exit;
 
-        complete = true;
-      });
+        expect(result['node']).to.be.a('string');
+        expect(result['dev']).to.equal(fs.name);
+        expect(result['size']).to.be.a('number');
+        expect(result['nlinks']).to.be.a('number');
+        expect(result['atime']).to.be.a('number');
+        expect(result['mtime']).to.be.a('number');
+        expect(result['ctime']).to.be.a('number');
+        expect(result['type']).to.equal('DIRECTORY');
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toBeDefined();
-        expect(_result['dev']).toEqual(that.db_name);
-        expect(_result['size']).toBeDefined();
-        expect(_result['nlinks']).toEqual(jasmine.any(Number));
-        expect(_result['atime']).toEqual(jasmine.any(Number));
-        expect(_result['mtime']).toEqual(jasmine.any(Number));
-        expect(_result['ctime']).toEqual(jasmine.any(Number));
-        expect(_result['type']).toBeDefined();
+        done();
       });
     });
 
-    it('should follow symbolic links and return a stat object for the resulting path', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
+    it('should follow symbolic links and return a stat object for the resulting path', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile', function(error, result) {
+          fs.stat('/myfile', function(error, result) {
             if(error) throw error;
 
-            _node = result['node'];
-            that.fs.symlink('/myfile', '/myfilelink', function(error) {
+            expect(result['node']).to.exist;
+            fs.symlink('/myfile', '/myfilelink', function(error) {
               if(error) throw error;
 
-              that.fs.stat('/myfilelink', function(error, result) {
-                _error = error;
-                _result = result;
-                complete = true;
+              fs.stat('/myfilelink', function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).to.exist;
+                expect(result['node']).to.exist;
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
-      });
     });
 
-    it('should return a stat object for a valid descriptor', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should return a stat object for a valid descriptor', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.fstat(fd, function(error, result) {
-          _error = error;
-          _result = result;
+        fs.fstat(fd, function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.exist;
 
-          complete = true;
+          expect(result['node']).to.exist;
+          expect(result['dev']).to.equal(fs.name);
+          expect(result['size']).to.be.a('number');
+          expect(result['nlinks']).to.be.a('number');
+          expect(result['atime']).to.be.a('number');
+          expect(result['mtime']).to.be.a('number');
+          expect(result['ctime']).to.be.a('number');
+          expect(result['type']).to.equal('FILE');
+
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toBeDefined();
-        expect(_result['dev']).toEqual(that.db_name);
-        expect(_result['size']).toBeDefined();
-        expect(_result['nlinks']).toEqual(jasmine.any(Number));
-        expect(_result['atime']).toEqual(jasmine.any(Number));
-        expect(_result['mtime']).toEqual(jasmine.any(Number));
-        expect(_result['ctime']).toEqual(jasmine.any(Number));
-        expect(_result['type']).toBeDefined();
-      });
     });
   });
 

tests/spec/fs.symlink.spec.js

@@ -1,83 +1,45 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.symlink', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.symlink).toEqual('function');
+      var fs = util.fs();
+      expect(fs.symlink).to.be.a('function');
     });
 
-    it('should return an error if part of the parent destination path does not exist', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if part of the parent destination path does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/', '/tmp/mydir', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.symlink('/', '/tmp/mydir', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should return an error if the destination path already exists', function() {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should return an error if the destination path already exists', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/tmp', '/', function(error) {
-        _error = error;
-
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.symlink('/tmp', '/', function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should create a symlink', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should create a symlink', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/', '/myfile', function(error, result) {
-        _error = error;
-        _result = result;
-        complete = true;
+      fs.symlink('/', '/myfile', function(error) {
+        expect(error).not.to.exist;
+
+        fs.stat('/myfile', function(err, stats) {
+          expect(error).not.to.exist;
+          expect(stats.type).to.equal('DIRECTORY');
+          done();
+        });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).not.toBeDefined();
-       });
     });
   });
 
-});
+});

tests/spec/fs.truncate.spec.js

@@ -1,261 +1,180 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.truncate', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.truncate).toEqual('function');
+      var fs = util.fs();
+      expect(fs.truncate).to.be.a('function');
     });
 
-    it('should error when length is negative', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should error when length is negative', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.writeFile('/myfile', contents, function(error) {
+      fs.writeFile('/myfile', contents, function(error) {
         if(error) throw error;
 
-        that.fs.truncate('/myfile', -1, function(error) {
-          _error = error;
-          complete = true;
+        fs.truncate('/myfile', -1, function(error) {
+          expect(error).to.exist;
+          done();
         });
       });
+    });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
+    it('should error when path is not a file', function(done) {
+      var fs = util.fs();
 
-      runs(function() {
-        expect(_error).toBeDefined();
+      fs.truncate('/', 0, function(error) {
+        expect(error).to.exist;
+        done();
       });
     });
 
-    it('should error when path is not a file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
-      that.fs.truncate('/', 0, function(error) {
-        _error = error;
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-      });
-    });
-
-    it('should truncate a file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should truncate a file', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var truncated = new Uint8Array([1]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.close(fd, function(error) {
+          fs.close(fd, function(error) {
             if(error) throw error;
 
-            that.fs.truncate('/myfile', 1, function(error) {
-              _error = error;
+            fs.truncate('/myfile', 1, function(error) {
+              expect(error).not.to.exist;
 
-              that.fs.readFile('/myfile', function(error, result) {
+              fs.readFile('/myfile', function(error, result) {
                 if(error) throw error;
 
-                _result = result;
-                complete = true;
+                expect(result).to.deep.equal(truncated);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(truncated);
-      });
     });
 
-    it('should pad a file with zeros when the length is greater than the file size', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should pad a file with zeros when the length is greater than the file size', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
       var truncated = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 0]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.close(fd, function(error) {
+          fs.close(fd, function(error) {
             if(error) throw error;
 
-            that.fs.truncate('/myfile', 9, function(error) {
-              _error = error;
+            fs.truncate('/myfile', 9, function(error) {
+              expect(error).not.to.exist;
 
-              that.fs.readFile('/myfile', function(error, result) {
+              fs.readFile('/myfile', function(error, result) {
                 if(error) throw error;
 
-                _result = result;
-                complete = true;
+                expect(result).to.deep.equal(truncated);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(truncated);
-      });
     });
 
-    it('should update the file size', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should update the file size', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.close(fd, function(error) {
+          fs.close(fd, function(error) {
             if(error) throw error;
 
-            that.fs.truncate('/myfile', 0, function(error) {
-              _error = error;
+            fs.truncate('/myfile', 0, function(error) {
+              expect(error).not.to.exist;
 
-              that.fs.stat('/myfile', function(error, result) {
+              fs.stat('/myfile', function(error, result) {
                 if(error) throw error;
 
-                _result = result;
-                complete = true;
+                expect(result.size).to.equal(0);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result.size).toEqual(0);
-      });
     });
 
-    it('should truncate a valid descriptor', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should truncate a valid descriptor', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.ftruncate(fd, 0, function(error) {
-            _error = error;
+          fs.ftruncate(fd, 0, function(error) {
+            expect(error).not.to.exist;
 
-            that.fs.fstat(fd, function(error, result) {
+            fs.fstat(fd, function(error, result) {
               if(error) throw error;
 
-              _result = result;
-              complete=true;
+              expect(result.size).to.equal(0);
+              done();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result.size).toEqual(0);
-      });
     });
 
-    it('should follow symbolic links', function() {
-      var complete = false;
-      var _error, _result, _result2;
-      var that = this;
-
+    it('should follow symbolic links', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
 
         var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
           if(error) throw error;
 
-          that.fs.close(fd, function(error) {
+          fs.close(fd, function(error) {
             if(error) throw error;
 
-            that.fs.symlink('/myfile', '/mylink', function(error) {
+            fs.symlink('/myfile', '/mylink', function(error) {
               if(error) throw error;
 
-              that.fs.truncate('/mylink', 0, function(error) {
-                _error = error;
+              fs.truncate('/mylink', 0, function(error) {
+                expect(error).not.to.exist;
 
-                that.fs.stat('/myfile', function(error, result) {
+                fs.stat('/myfile', function(error, result) {
                   if(error) throw error;
 
-                  _result = result;
-                  that.fs.lstat('/mylink', function(error, result) {
+                  expect(result.size).to.equal(0);
+                  fs.lstat('/mylink', function(error, result) {
                     if(error) throw error;
 
-                    _result2 = result;
-                    complete=true;
+                    expect(result.size).not.to.equal(0);
+                    done();
                   });
                 });
               });
@@ -263,16 +182,6 @@ define(["Filer"], function(Filer) {
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result.size).toEqual(0);
-        expect(_result2.size).not.toEqual(0);
-      });
     });
   });
 });

tests/spec/fs.unlink.spec.js

@@ -1,109 +1,84 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.unlink', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.unlink).toEqual('function');
+      var fs = util.fs();
+      expect(fs.unlink).to.be.a('function');
     });
 
-    it('should remove a link to an existing file', function() {
-      var complete1 = false;
-      var complete2 = false;
-      var _error, _stats;
-      var that = this;
+    it('should remove a link to an existing file', function(done) {
+      var fs = util.fs();
+      var complete1, complete2;
 
-      that.fs.open('/myfile', 'w+', function(error, result) {
+      function maybeDone() {
+        if(complete1 && complete2) {
+          done();
+        }
+      }
+
+      fs.open('/myfile', 'w+', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
 
-          that.fs.link('/myfile', '/myotherfile', function(error) {
+          fs.link('/myfile', '/myotherfile', function(error) {
             if(error) throw error;
 
-            that.fs.unlink('/myfile', function(error) {
+            fs.unlink('/myfile', function(error) {
               if(error) throw error;
 
-              that.fs.stat('/myfile', function(error, result) {
-                _error = error;
+              fs.stat('/myfile', function(error, result) {
+                expect(error).to.exist;
                 complete1 = true;
+                maybeDone();
               });
 
-              that.fs.stat('/myotherfile', function(error, result) {
+              fs.stat('/myotherfile', function(error, result) {
                 if(error) throw error;
 
-                _stats = result;
+                expect(result.nlinks).to.equal(1);
                 complete2 = true;
+                maybeDone();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete1 && complete2;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_stats.nlinks).toEqual(1);
-      });
     });
 
-    it('should not follow symbolic links', function () {
-      var complete = false;
-      var _error, _stats1, _stats2;
-      var that = this;
+    it('should not follow symbolic links', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/', '/myFileLink', function (error) {
+      fs.symlink('/', '/myFileLink', function (error) {
         if (error) throw error;
 
-        that.fs.link('/myFileLink', '/myotherfile', function (error) {
+        fs.link('/myFileLink', '/myotherfile', function (error) {
           if (error) throw error;
 
-          that.fs.unlink('/myFileLink', function (error) {
+          fs.unlink('/myFileLink', function (error) {
             if (error) throw error;
 
-            that.fs.lstat('/myFileLink', function (error, result) {
-              _error = error;
+            fs.lstat('/myFileLink', function (error, result) {
+              expect(error).to.exist;
 
-              that.fs.lstat('/myotherfile', function (error, result) {
+              fs.lstat('/myotherfile', function (error, result) {
                 if (error) throw error;
-                _stats1 = result;
+                expect(result.nlinks).to.equal(1);
 
-                that.fs.stat('/', function (error, result) {
+                fs.stat('/', function (error, result) {
                   if (error) throw error;
-                  _stats2 = result;
-                  complete = true;
+                  expect(result.nlinks).to.equal(1);
+                  done();
                 });
               });
             });
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_stats1.nlinks).toEqual(1);
-        expect(_stats2.nlinks).toEqual(1);
-      });
     });
   });
 

tests/spec/fs.utimes.spec.js

@@ -1,314 +1,183 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.utimes', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.utimes).toEqual('function');
+      var fs = util.fs();
+      expect(fs.utimes).to.be.a('function');
     });
 
-    it('should error when atime is negative', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when atime is negative', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function(error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.utimes('/testfile', -1, Date.now(), function (error) {
-          _error = error;
-          complete = true;
+        fs.utimes('/testfile', -1, Date.now(), function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when mtime is negative', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when mtime is negative', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function(error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.utimes('/testfile', Date.now(), -1, function (error) {
-          _error = error;
-          complete = true;
+        fs.utimes('/testfile', Date.now(), -1, function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when atime is as invalid number', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when atime is as invalid number', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.utimes('/testfile', 'invalid datetime', Date.now(), function (error) {
-          _error = error;
-          complete = true;
+        fs.utimes('/testfile', 'invalid datetime', Date.now(), function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it ('should error when path does not exist', function () {
-      var complete = false;
-      var _error;
-      var that = this;
-
+    it('should error when path does not exist', function(done) {
+      var fs = util.fs();
       var atime = Date.parse('1 Oct 2000 15:33:22');
       var mtime = Date.parse('30 Sep 2000 06:43:54');
 
-      that.fs.utimes('/pathdoesnotexist', atime, mtime, function (error) {
-        _error = error;
-        complete = true;
-      });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('ENoEntry');
+      fs.utimes('/pathdoesnotexist', atime, mtime, function (error) {
+        expect(error).to.exist;
+        expect(error.name).to.equal('ENoEntry');
+        done();
       });
     });
 
-    it('should error when mtime is an invalid number', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when mtime is an invalid number', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.utimes('/testfile', Date.now(), 'invalid datetime', function (error) {
-          _error = error;
-          complete = true;
+        fs.utimes('/testfile', Date.now(), 'invalid datetime', function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it ('should error when file descriptor is invalid', function () {
-      var complete = false;
-      var _error;
-      var that = this;
-
+    it('should error when file descriptor is invalid', function(done) {
+      var fs = util.fs();
       var atime = Date.parse('1 Oct 2000 15:33:22');
       var mtime = Date.parse('30 Sep 2000 06:43:54');
 
-      that.fs.futimes(1, atime, mtime, function (error) {
-        _error = error;
-        complete = true;
-      });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EBadFileDescriptor');
+      fs.futimes(1, atime, mtime, function (error) {
+        expect(error).to.exist;
+        expect(error.name).to.equal('EBadFileDescriptor');
+        done();
       });
     });
 
-    it('should change atime and mtime of a file path', function () {
-      var complete = false;
-      var _error;
-      var that = this;
-
-      var _stat;
-
+    it('should change atime and mtime of a file path', function(done) {
+      var fs = util.fs();
       var atime = Date.parse('1 Oct 2000 15:33:22');
       var mtime = Date.parse('30 Sep 2000 06:43:54');
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.utimes('/testfile', atime, mtime, function (error) {
-          _error = error;
+        fs.utimes('/testfile', atime, mtime, function (error) {
+          expect(error).not.to.exist;
 
-          that.fs.stat('/testfile', function (error, stat) {
-            if (error) throw error;
-
-            _stat = stat;
-            complete = true;
+          fs.stat('/testfile', function (error, stat) {
+            expect(error).not.to.exist;
+            expect(stat.atime).to.equal(atime);
+            expect(stat.mtime).to.equal(mtime);
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_stat.atime).toEqual(atime);
-        expect(_stat.mtime).toEqual(mtime);
-      });
     });
 
-    it ('should change atime and mtime for a valid file descriptor', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
-
+    it ('should change atime and mtime for a valid file descriptor', function(done) {
+      var fs = util.fs();
       var ofd;
-      var _stat;
-
       var atime = Date.parse('1 Oct 2000 15:33:22');
       var mtime = Date.parse('30 Sep 2000 06:43:54');
 
-      that.fs.open('/testfile', 'w', function (error, result) {
+      fs.open('/testfile', 'w', function (error, result) {
         if (error) throw error;
 
         ofd = result;
+        fs.futimes(ofd, atime, mtime, function (error) {
+          expect(error).not.to.exist;
 
-        that.fs.futimes(ofd, atime, mtime, function (error) {
-          _error = error;
-
-          that.fs.fstat(ofd, function (error, stat) {
-            if (error) throw error;
-
-            _stat = stat;
-            complete = true;
+          fs.fstat(ofd, function (error, stat) {
+            expect(error).not.to.exist;
+            expect(stat.atime).to.equal(atime);
+            expect(stat.mtime).to.equal(mtime);
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_stat.atime).toEqual(atime);
-        expect(_stat.mtime).toEqual(mtime);
-      });
     });
 
-    it ('should update atime and mtime of directory path', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
-
-      var _stat;
-
+    it('should update atime and mtime of directory path', function(done) {
+      var fs = util.fs();
       var atime = Date.parse('1 Oct 2000 15:33:22');
       var mtime = Date.parse('30 Sep 2000 06:43:54');
 
-      that.fs.mkdir('/testdir', function (error) {
+      fs.mkdir('/testdir', function (error) {
         if (error) throw error;
 
-        that.fs.utimes('/testdir', atime, mtime, function (error) {
-          _error = error;
+        fs.utimes('/testdir', atime, mtime, function (error) {
+          expect(error).not.to.exist;
 
-          that.fs.stat('/testdir', function (error, stat) {
-            if (error) throw error;
-
-            _stat = stat;
-            complete = true;
+          fs.stat('/testdir', function (error, stat) {
+            expect(error).not.to.exist;
+            expect(stat.atime).to.equal(atime);
+            expect(stat.mtime).to.equal(mtime);
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_stat.atime).toEqual(atime);
-        expect(_stat.mtime).toEqual(mtime);
-      });
     });
 
-    it ('should update atime and mtime using current time if arguments are null', function () {
-      var complete = false;
-      var _error;
-      var that = this;
-
+    it('should update atime and mtime using current time if arguments are null', function(done) {
+      var fs = util.fs();
       var atimeEst;
       var mtimeEst;
       var now;
 
-      that.fs.writeFile('/myfile', '', function (error) {
+      fs.writeFile('/myfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.utimes('/myfile', null, null, function (error) {
-          _error = error;
+        fs.utimes('/myfile', null, null, function (error) {
+          expect(error).not.to.exist;
 
           now = Date.now();
 
-          that.fs.stat('/myfile', function (error, stat) {
-            if (error) throw error;
-
-            atimeEst = now - stat.atime;
-            mtimeEst = now - stat.mtime;
-            complete = true;
+          fs.stat('/myfile', function (error, stat) {
+            expect(error).not.to.exist;
+            // Note: testing estimation as time may differ by a couple of milliseconds
+            // This number should be increased if tests are on slow systems
+            expect(now - stat.atime).to.be.below(25);
+            expect(now - stat.mtime).to.be.below(25);
+            done();
           });
         });
       });
-
-      waitsFor(function (){
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        // Note: testing estimation as time may differ by a couple of milliseconds
-        // This number should be increased if tests are on slow systems
-        expect(atimeEst).toBeLessThan(10);
-        expect(mtimeEst).toBeLessThan(10);
-      });
     });
   });
-});
+});

tests/spec/fs.write.spec.js

@@ -1,99 +1,61 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.write', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.write).toEqual('function');
+      var fs = util.fs();
+      expect(fs.write).to.be.a('function');
     });
 
-    it('should write data to a file', function() {
-      var complete = false;
-      var _error, _result, _stats;
-      var that = this;
-
+    it('should write data to a file', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
-          _error = error;
-          _result = result;
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.equal(buffer.length);
 
-          that.fs.stat('/myfile', function(error, result) {
-            if(error) throw error;
-
-            _stats = result;
-
-            complete = true;
+          fs.stat('/myfile', function(error, result) {
+            expect(error).not.to.exist;
+            expect(result.type).to.equal('FILE');
+            expect(result.size).to.equal(buffer.length);
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(buffer.length);
-        expect(_stats.size).toEqual(buffer.length);
-      });
     });
 
-    it('should update the current file position', function() {
-      var complete = false;
-      var _error, _result, _stats;
-      var that = this;
-
+    it('should update the current file position', function(done) {
+      var fs = util.fs();
       var buffer = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-      _result = 0;
+      var _result = 0;
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, fd) {
         if(error) throw error;
 
-        var fd = result;
-        that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+        fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
           if(error) throw error;
           _result += result;
 
-          that.fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
+          fs.write(fd, buffer, 0, buffer.length, undefined, function(error, result) {
             if(error) throw error;
             _result += result;
 
-            that.fs.stat('/myfile', function(error, result) {
+            fs.stat('/myfile', function(error, result) {
               if(error) throw error;
-
-              _stats = result;
-
-              complete = true;
+              expect(error).not.to.exist;
+              expect(_result).to.equal(2 * buffer.length);
+              expect(result.size).to.equal(_result);
+              done();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(2 * buffer.length);
-        expect(_stats.size).toEqual(_result);
-      });
     });
   });
 

tests/spec/fs.writeFile-readFile.spec.js

@@ -1,182 +1,102 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.writeFile, fs.readFile', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function() {
-      expect(typeof this.fs.writeFile).toEqual('function');
-      expect(typeof this.fs.readFile).toEqual('function');
+      var fs = util.fs();
+      expect(fs.writeFile).to.be.a('function');
+      expect(fs.readFile).to.be.a('function');
     });
 
-    it('should error when path is wrong to readFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should error when path is wrong to readFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.readFile('/no-such-file', 'utf8', function(error, data) {
-        _error = error;
-        _result = data;
-        complete = true;
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
+      fs.readFile('/no-such-file', 'utf8', function(error, data) {
+        expect(error).to.exist;
+        expect(data).not.to.exist;
+        done();
       });
     });
 
-    it('should write, read a utf8 file without specifying utf8 in writeFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should write, read a utf8 file without specifying utf8 in writeFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.writeFile('/myfile', contents, function(error) {
+      fs.writeFile('/myfile', contents, function(error) {
         if(error) throw error;
-        that.fs.readFile('/myfile', 'utf8', function(error2, data) {
-          if(error2) throw error2;
-          _result = data;
-          complete = true;
+        fs.readFile('/myfile', 'utf8', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents);
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents);
-      });
     });
 
-    it('should write, read a utf8 file with "utf8" option to writeFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should write, read a utf8 file with "utf8" option to writeFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.writeFile('/myfile', contents, 'utf8', function(error) {
+      fs.writeFile('/myfile', contents, 'utf8', function(error) {
         if(error) throw error;
-        that.fs.readFile('/myfile', 'utf8', function(error2, data) {
-          if(error2) throw error2;
-          _result = data;
-          complete = true;
+        fs.readFile('/myfile', 'utf8', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents);
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents);
-      });
     });
 
-    it('should write, read a utf8 file with {encoding: "utf8"} option to writeFile', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should write, read a utf8 file with {encoding: "utf8"} option to writeFile', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.writeFile('/myfile', contents, { encoding: 'utf8' }, function(error) {
+      fs.writeFile('/myfile', contents, { encoding: 'utf8' }, function(error) {
         if(error) throw error;
-        that.fs.readFile('/myfile', 'utf8', function(error2, data) {
-          if(error2) throw error2;
-          _result = data;
-          complete = true;
+        fs.readFile('/myfile', 'utf8', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.equal(contents);
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(contents);
-      });
     });
 
-    it('should write, read a binary file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
-
+    it('should write, read a binary file', function(done) {
+      var fs = util.fs();
       // String and utf8 binary encoded versions of the same thing:
       var contents = "This is a file.";
       var binary = new Uint8Array([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
 
-      that.fs.writeFile('/myfile', binary, function(error) {
+      fs.writeFile('/myfile', binary, function(error) {
         if(error) throw error;
-        that.fs.readFile('/myfile', function(error2, data) {
-          if(error2) throw error2;
-          _result = data;
-          complete = true;
+        fs.readFile('/myfile', function(error, data) {
+          expect(error).not.to.exist;
+          expect(data).to.deep.equal(binary);
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toEqual(null);
-        expect(_result).toEqual(binary);
-      });
     });
 
-    it('should follow symbolic links', function () {
-      var complete = false;
-      var _result;
-      var that = this;
-
+    it('should follow symbolic links', function(done) {
+      var fs = util.fs();
       var contents = "This is a file.";
 
-      that.fs.writeFile('/myfile', '', { encoding: 'utf8' }, function(error) {
+      fs.writeFile('/myfile', '', { encoding: 'utf8' }, function(error) {
         if(error) throw error;
-        that.fs.symlink('/myfile', '/myFileLink', function (error) {
+        fs.symlink('/myfile', '/myFileLink', function (error) {
           if (error) throw error;
-          that.fs.writeFile('/myFileLink', contents, 'utf8', function (error) {
+          fs.writeFile('/myFileLink', contents, 'utf8', function (error) {
             if (error) throw error;
-            that.fs.readFile('/myFileLink', 'utf8', function(error, data) {
-              if(error) throw error;
-              _result = data;
-              complete = true;
+            fs.readFile('/myFileLink', 'utf8', function(error, data) {
+              expect(error).not.to.exist;
+              expect(data).to.equal(contents);
+              done();
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toEqual(contents);
-      });
     });
   });
 

tests/spec/fs.xattr.spec.js

@@ -1,448 +1,287 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('fs.xattr', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     it('should be a function', function () {
-      expect(typeof this.fs.setxattr).toEqual('function');
-      expect(typeof this.fs.getxattr).toEqual('function');
-      expect(typeof this.fs.removexattr).toEqual('function');
-      expect(typeof this.fs.fsetxattr).toEqual('function');
-      expect(typeof this.fs.fgetxattr).toEqual('function');
+      var fs = util.fs();
+      expect(fs.setxattr).to.be.a('function');
+      expect(fs.getxattr).to.be.a('function');
+      expect(fs.removexattr).to.be.a('function');
+      expect(fs.fsetxattr).to.be.a('function');
+      expect(fs.fgetxattr).to.be.a('function');
     });
 
-    it('should error when setting with a name that is not a string', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when setting with a name that is not a string', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 89, 'testvalue', function (error) {
-          _error = error;
-          complete = true;
+        fs.setxattr('/testfile', 89, 'testvalue', function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when setting with a name that is null', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when setting with a name that is null', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', null, 'testvalue', function (error) {
-          _error = error;
-          complete = true;
+        fs.setxattr('/testfile', null, 'testvalue', function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when setting with an invalid flag', function () {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when setting with an invalid flag', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 'value', 'InvalidFlag', function (error) {
-          _error = error;
-          complete = true;
+        fs.setxattr('/testfile', 'test', 'value', 'InvalidFlag', function (error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when when setting an extended attribute which exists with XATTR_CREATE flag', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when when setting an extended attribute which exists with XATTR_CREATE flag', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 'value', function (error) {
+        fs.setxattr('/testfile', 'test', 'value', function(error) {
           if (error) throw error;
 
-          that.fs.setxattr('/testfile', 'test', 'othervalue', 'CREATE', function (error) {
-            _error = error;
-            complete = true;
+          fs.setxattr('/testfile', 'test', 'othervalue', 'CREATE', function(error) {
+            expect(error).to.exist;
+            expect(error.name).to.equal('EExists');
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EExists');
-      });
     });
 
-    it('should error when setting an extended attribute which does not exist with XATTR_REPLACE flag', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when setting an extended attribute which does not exist with XATTR_REPLACE flag', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 'value', 'REPLACE', function (error) {
-          _error = error;
-          complete = true;
+        fs.setxattr('/testfile', 'test', 'value', 'REPLACE', function(error) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('ENoAttr');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('ENoAttr');
-      });
     });
 
-    it ('should error when getting an attribute with a name that is empty', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when getting an attribute with a name that is empty', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.getxattr('/testfile', '', function (error, value) {
-          _error = error;
-          complete = true;
+        fs.getxattr('/testfile', '', function(error, value) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when getting an attribute where the name is not a string', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when getting an attribute where the name is not a string', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.getxattr('/testfile', 89, function (error, value) {
-          _error = error;
-          complete = true;
+        fs.getxattr('/testfile', 89, function(error, value) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('EInvalid');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('EInvalid');
-      });
     });
 
-    it('should error when getting an attribute that does not exist', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when getting an attribute that does not exist', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function(error) {
         if (error) throw error;
 
-        that.fs.getxattr('/testfile', 'test', function (error, value) {
-          _error = error;
-          complete = true;
+        fs.getxattr('/testfile', 'test', function(error, value) {
+          expect(error).to.exist;
+          expect(error.name).to.equal('ENoAttr');
+          done();
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('ENoAttr');
-      });
     });
 
-    it('should error when file descriptor is invalid', function (error) {
+    it('should error when file descriptor is invalid', function(done) {
+      var fs = util.fs();
       var completeSet, completeGet, completeRemove;
-      var _errorSet, _errorGet, _errorRemove;
-      var that = this;
       var _value;
 
       completeSet = completeGet = completeRemove = false;
 
-      that.fs.fsetxattr(1, 'test', 'value', function (error) {
-        _errorSet = error;
+      function maybeDone() {
+        if(completeSet && completeGet && completeRemove) {
+          done();
+        }
+      }
+
+      fs.fsetxattr(1, 'test', 'value', function(error) {
+        expect(error).to.exist;
+        expect(error.name).to.equal('EBadFileDescriptor');
         completeSet = true;
+        maybeDone();
       });
 
-      that.fs.fgetxattr(1, 'test', function (error, value) {
-        _errorGet = error;
-        _value = value;
+      fs.fgetxattr(1, 'test', function(error, value) {
+        expect(error).to.exist;
+        expect(error.name).to.equal('EBadFileDescriptor');
+        expect(value).not.to.exist;
         completeGet = true;
+        maybeDone();
       });
 
-      that.fs.fremovexattr(1, 'test', function (error, value) {
-        _errorRemove = error;
+      fs.fremovexattr(1, 'test', function(error, value) {
+        expect(error).to.exist;
+        expect(error.name).to.equal('EBadFileDescriptor');
         completeRemove = true;
-      });
-
-      waitsFor(function () {
-        return completeSet && completeGet && completeRemove;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_value).toEqual(null);
-        expect(_errorSet).toBeDefined();
-        expect(_errorSet.name).toEqual('EBadFileDescriptor');
-        expect(_errorGet).toBeDefined();
-        expect(_errorGet.name).toEqual('EBadFileDescriptor');
-        expect(_errorRemove).toBeDefined();
-        expect(_errorRemove.name).toEqual('EBadFileDescriptor');
+        maybeDone();
       });
     });
 
-    it('should set and get an extended attribute of a path', function (error) {
-      var complete = false;
-      var _errorSet;
-      var that = this;
+    it('should set and get an extended attribute of a path', function(done) {
+      var fs = util.fs();
       var name = 'test';
-      var _value;;
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', name, 'somevalue', function (error) {
-          _errorSet = error;
+        fs.setxattr('/testfile', name, 'somevalue', function(error) {
+          expect(error).not.to.exist;
 
-          that.fs.getxattr('/testfile', name, function (error, value) {
-            _errorGet = error;
-            _value = value;
-            complete = true;
+          fs.getxattr('/testfile', name, function(error, value) {
+            expect(error).not.to.exist;
+            expect(value).to.equal('somevalue');
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_errorSet).toEqual(null);
-        expect(_errorGet).toEqual(null);
-        expect(_value).toEqual('somevalue');
-      });
     });
 
-    it('should error when attempting to remove a non-existing attribute', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
+    it('should error when attempting to remove a non-existing attribute', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', '', function (error) {
+        fs.setxattr('/testfile', 'test', '', function (error) {
           if (error) throw error;
 
-          that.fs.removexattr('/testfile', 'testenoattr', function (error) {
-            _error = error;
-            complete = true;
+          fs.removexattr('/testfile', 'testenoattr', function (error) {
+            expect(error).to.exist;
+            expect(error.name).to.equal('ENoAttr');
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('ENoAttr');
-      });
     });
 
-    it('should set and get an empty string as a value', function (error) {
-      var complete = false;
-      var _error;
-      var _value;
-      var that = this;
+    it('should set and get an empty string as a value', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', '', function (error) {
-          _error = error;
+        fs.setxattr('/testfile', 'test', '', function (error) {
+          if(error) throw error;
 
-          that.fs.getxattr('/testfile', 'test', function (error, value) {
-            _error = error;
-            _value = value;
-            complete = true;
+          fs.getxattr('/testfile', 'test', function (error, value) {
+            expect(error).not.to.exist;
+            expect(value).to.equal('');
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_value).toBeDefined();
-        expect(_value).toEqual('');
-      });
     });
 
-    it('should set and get an extended attribute for a valid file descriptor', function (error) {
-      var complete = false;
-      var _errorSet, _errorGet;
-      var _value;
-      var that = this;
-      var ofd;
+    it('should set and get an extended attribute for a valid file descriptor', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/testfile', 'w', function (error, result) {
+      fs.open('/testfile', 'w', function (error, ofd) {
         if (error) throw error;
 
-        ofd = result;
+        fs.fsetxattr(ofd, 'test', 'value', function (error) {
+          expect(error).not.to.exist;
 
-        that.fs.fsetxattr(ofd, 'test', 'value', function (error) {
-          _errorSet = error;
-
-          that.fs.fgetxattr(ofd, 'test', function (error, value) {
-            _errorGet = error;
-            _value = value;
-            complete = true;
+          fs.fgetxattr(ofd, 'test', function (error, value) {
+            expect(error).not.to.exist;
+            expect(value).to.equal('value');
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_errorSet).toEqual(null);
-        expect(_errorGet).toEqual(null);
-        expect(_value).toBeDefined();
-        expect(_value).toEqual('value');
-      });
     });
 
-    it('should set and get an object to an extended attribute', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
-      var value;
+    it('should set and get an object to an extended attribute', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', { key1: 'test', key2: 'value', key3: 87 }, function (error) {
-          _error = error;
+        fs.setxattr('/testfile', 'test', { key1: 'test', key2: 'value', key3: 87 }, function (error) {
+          if(error) throw error;
 
-          that.fs.getxattr('/testfile', 'test', function (error, value) {
-            _error = error;
-            _value = value;
-            complete = true;
+          fs.getxattr('/testfile', 'test', function (error, value) {
+            expect(error).not.to.exist;
+            expect(value).to.deep.equal({ key1: 'test', key2: 'value', key3: 87 });
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_value).toEqual({ key1: 'test', key2: 'value', key3: 87 });
-      });
     });
 
-    it('should update/overwrite an existing extended attribute', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
-      var _value1, _value2, _value3;
+    it('should update/overwrite an existing extended attribute', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 'value', function (error) {
-          _error = error;
+        fs.setxattr('/testfile', 'test', 'value', function (error) {
+          if (error) throw error;
 
-          that.fs.getxattr('/testfile', 'test', function (error, value) {
-            _error = error;
-            _value1 = value;
+          fs.getxattr('/testfile', 'test', function (error, value) {
+            if (error) throw error;
+            expect(value).to.equal('value');
 
-            that.fs.setxattr('/testfile', 'test', { o: 'object', t: 'test' }, function (error) {
-              _error = error;
+            fs.setxattr('/testfile', 'test', { o: 'object', t: 'test' }, function (error) {
+              if (error) throw error;
 
-              that.fs.getxattr('/testfile', 'test', function (error, value) {
-                _error = error;
-                _value2 = value;
+              fs.getxattr('/testfile', 'test', function (error, value) {
+                if (error) throw error;
+                expect(value).to.deep.equal({ o: 'object', t: 'test' });
 
-                that.fs.setxattr('/testfile', 'test', 100, 'REPLACE', function (error) {
-                  _error = error;
+                fs.setxattr('/testfile', 'test', 100, 'REPLACE', function (error) {
+                  if (error) throw error;
 
-                  that.fs.getxattr('/testfile', 'test', function (error, value) {
-                    _error = error;
-                    _value3 = value;
-                    complete = true;
+                  fs.getxattr('/testfile', 'test', function (error, value) {
+                    expect(value).to.equal(100);
+                    done();
                   });
                 });
               });
@@ -450,170 +289,105 @@ define(["Filer"], function(Filer) {
           });
         })
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete' , DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_value1).toEqual('value');
-        expect(_value2).toEqual({ o: 'object', t: 'test' });
-        expect(_value3).toEqual(100);
-      });
     });
 
-    it('should set multiple extended attributes for a path', function (error) {
-      var complete = false;
-      var _error;
-      var that = this;
-      var _value1, _value2;
+    it('should set multiple extended attributes for a path', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 89, function (error) {
-          _error = error;
+        fs.setxattr('/testfile', 'test', 89, function (error) {
+          if (error) throw error;
 
-          that.fs.setxattr('/testfile', 'other', 'attribute', function (error) {
-            _error = error;
+          fs.setxattr('/testfile', 'other', 'attribute', function (error) {
+            if(error) throw error;
 
-            that.fs.getxattr('/testfile', 'test', function (error, value) {
-              _error = error;
-              _value1 = value;
+            fs.getxattr('/testfile', 'test', function (error, value) {
+              if(error) throw error;
+              expect(value).to.equal(89);
 
-              that.fs.getxattr('/testfile', 'other', function (error, value) {
-                _error = error;
-                _value2 = value;
-                complete = true;
+              fs.getxattr('/testfile', 'other', function (error, value) {
+                expect(error).not.to.exist;
+                expect(value).to.equal('attribute');
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_value1).toEqual(89);
-        expect(_value2).toEqual('attribute');
-      });
     });
 
-    it('should remove an extended attribute from a path', function (error) {
-      var complete = false;
-      var _error, _value;
-      var that = this;
+    it('should remove an extended attribute from a path', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', 'somevalue', function (error) {
+        fs.setxattr('/testfile', 'test', 'somevalue', function (error) {
           if (error) throw error;
 
-          that.fs.getxattr('/testfile', 'test', function (error, value) {
+          fs.getxattr('/testfile', 'test', function (error, value) {
             if (error) throw error;
+            expect(value).to.equal('somevalue');
 
-            _value = value;
-
-            that.fs.removexattr('/testfile', 'test', function (error) {
+            fs.removexattr('/testfile', 'test', function (error) {
               if (error) throw error;
 
-              that.fs.getxattr('/testfile', 'test', function (error) {
-                _error = error;
-                complete = true;
+              fs.getxattr('/testfile', 'test', function (error) {
+                expect(error).to.exist;
+                expect(error.name).to.equal('ENoAttr');
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_value).toBeDefined();
-        expect(_value).toEqual('somevalue');
-        expect(_error.name).toEqual('ENoAttr');
-      });
     });
 
-    it('should remove an extended attribute from a valid file descriptor', function () {
-      var complete = false;
-      var _error, _value;
-      var that = this;
-      var ofd;
+    it('should remove an extended attribute from a valid file descriptor', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/testfile', 'w', function (error, result) {
+      fs.open('/testfile', 'w', function (error, ofd) {
         if (error) throw error;
 
-        var ofd = result;
-
-        that.fs.fsetxattr(ofd, 'test', 'somevalue', function (error) {
+        fs.fsetxattr(ofd, 'test', 'somevalue', function (error) {
           if (error) throw error;
 
-          that.fs.fgetxattr(ofd, 'test', function (error, value) {
+          fs.fgetxattr(ofd, 'test', function (error, value) {
             if (error) throw error;
+            expect(value).to.equal('somevalue');
 
-            _value = value;
-
-            that.fs.fremovexattr(ofd, 'test', function (error) {
+            fs.fremovexattr(ofd, 'test', function (error) {
               if (error) throw error;
 
-              that.fs.fgetxattr(ofd, 'test', function (error) {
-                _error = error;
-                complete = true;
+              fs.fgetxattr(ofd, 'test', function (error) {
+                expect(error).to.exist;
+                expect(error.name).to.equal('ENoAttr');
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toBeDefined();
-        expect(_value).toBeDefined();
-        expect(_value).toEqual('somevalue');
-        expect(_error.name).toEqual('ENoAttr');
-      });
     });
 
-    it('should allow setting with a null value', function () {
-      var complete = false;
-      var _error;
-      var _value;
-      var that = this;
+    it('should allow setting with a null value', function(done) {
+      var fs = util.fs();
 
-      that.fs.writeFile('/testfile', '', function (error) {
+      fs.writeFile('/testfile', '', function (error) {
         if (error) throw error;
 
-        that.fs.setxattr('/testfile', 'test', null, function (error) {
+        fs.setxattr('/testfile', 'test', null, function (error) {
           if (error) throw error;
 
-          that.fs.getxattr('/testfile', 'test', function (error, value) {
-            _error = error;
-            _value = value;
-            complete = true;
+          fs.getxattr('/testfile', 'test', function (error, value) {
+            expect(error).not.to.exist;
+            expect(value).to.be.null;
+            done();
           });
         });
       });
-
-      waitsFor(function () {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function () {
-        expect(_error).toEqual(null);
-        expect(_value).toEqual(null);
-      });
     });
   });
-});
+});

tests/spec/node-js/simple/test-fs-mkdir.js

@@ -1,74 +1,41 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe("node.js tests: https://github.com/joyent/node/blob/master/test/simple/test-fs-mkdir.js", function() {
 
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
     // Based on test1 from https://github.com/joyent/node/blob/master/test/simple/test-fs-mkdir.js
-    it('should create a dir without a mode arg', function() {
-      var _error, _result;
-      var complete = false;
+    it('should create a dir without a mode arg', function(done) {
       var pathname = '/test1';
-      var fs = this.fs;
+      var fs = util.fs();
 
-      fs.mkdir(pathname, function(err) {
-        _error = err;
-        fs.stat(pathname, function(err, result) {
-          _error = _error || err;
-          _result = result;
-
-          complete = true;
+      fs.mkdir(pathname, function(error) {
+        if(error) throw error;
+        fs.stat(pathname, function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.exist;
+          expect(result.type).to.equal('DIRECTORY');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_error).toEqual(null);
-      });
     });
 
     // Based on test2 https://github.com/joyent/node/blob/master/test/simple/test-fs-mkdir.js
-    it('should create a dir with a mode arg', function() {
-      var _error, _result;
-      var complete = false;
+    it('should create a dir with a mode arg', function(done) {
       var pathname = '/test2';
-      var fs = this.fs;
+      var fs = util.fs();
 
-      fs.mkdir(pathname, 511 /*=0777*/, function(err) {
-        _error = err;
-        fs.stat(pathname, function(err, result) {
-          _error = _error || err;
-          _result = result;
-
-          complete = true;
+      fs.mkdir(pathname, 511 /*=0777*/, function(error) {
+        if(error) throw error;
+        fs.stat(pathname, function(error, result) {
+          expect(error).not.to.exist;
+          expect(result).to.exist;
+          expect(result.type).to.equal('DIRECTORY');
+          done();
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_error).toEqual(null);
-      });
     });
-
   });
 
 });

tests/spec/node-js/simple/test-fs-null-bytes.js

@@ -1,38 +1,29 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe("node.js tests: https://github.com/joyent/node/blob/master/test/simple/test-fs-null-bytes.js", function() {
 
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
-
-    it('should reject paths with null bytes in them', function() {
-      var complete = false;
+    it('should reject paths with null bytes in them', function(done) {
       var checks = [];
       var fnCount = 0;
       var fnTotal = 16;
       var expected = "Path must be a string without null bytes.";
-      var fs = this.fs;
+      var fs = util.fs();
 
       // Make sure function fails with null path error in callback.
       function check(fn) {
         var args = Array.prototype.slice.call(arguments, 1);
         args = args.concat(function(err) {
           checks.push(function(){
-            expect(err).toBeDefined();
-            expect(err.message).toEqual(expected);
+            expect(err).to.exist;
+            expect(err.message).to.equal(expected);
           });
           fnCount++;
-          complete = fnCount === fnTotal;
+          if(fnCount === fnTotal) {
+            done();
+          }
         });
 
         fn.apply(fs, args);
@@ -54,24 +45,18 @@ define(["Filer"], function(Filer) {
       check(fs.symlink,     'foobar', 'foo\u0000bar');
       check(fs.unlink,      'foo\u0000bar');
       check(fs.writeFile,   'foo\u0000bar');
+      check(fs.appendFile,  'foo\u0000bar');
+      check(fs.truncate,    'foo\u0000bar');
+      check(fs.utimes,      'foo\u0000bar', 0, 0);
       // TODO - need to be implemented still...
-      //  check(fs.appendFile,  'foo\u0000bar');
       //  check(fs.realpath,    'foo\u0000bar');
       //  check(fs.chmod,       'foo\u0000bar', '0644');
       //  check(fs.chown,       'foo\u0000bar', 12, 34);
       //  check(fs.realpath,    'foo\u0000bar');
-      //  check(fs.truncate,    'foo\u0000bar');
-      //  check(fs.utimes,      'foo\u0000bar', 0, 0);
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        checks.forEach(function(fn){
-          fn();
-        });
+      checks.forEach(function(fn){
+        fn();
       });
     });
   });
-});
+});

tests/spec/path-resolution.spec.js

@@ -1,199 +1,133 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
 
   describe('path resolution', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
+    beforeEach(util.setup);
+    afterEach(util.cleanup);
 
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
+    it('should follow a symbolic link to the root directory', function(done) {
+      var fs = util.fs();
 
-    it('should follow a symbolic link to the root directory', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
-
-      that.fs.symlink('/', '/mydirectorylink', function(error) {
+      fs.symlink('/', '/mydirectorylink', function(error) {
         if(error) throw error;
 
-        that.fs.stat('/', function(error, result) {
+        fs.stat('/', function(error, result) {
           if(error) throw error;
 
-            _node = result['node'];
-            that.fs.stat('/mydirectorylink', function(error, result) {
-              _error = error;
-              _result = result;
-              complete = true;
-            });
-        });
-      });
+          expect(result['node']).to.exist;
+          var _node = result['node'];
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
-      });
-    });
-
-    it('should follow a symbolic link to a directory', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
-
-      that.fs.mkdir('/mydir', function(error) {
-        that.fs.symlink('/mydir', '/mydirectorylink', function(error) {
-          if(error) throw error;
-
-          that.fs.stat('/mydir', function(error, result) {
-            if(error) throw error;
-
-              _node = result['node'];
-              that.fs.stat('/mydirectorylink', function(error, result) {
-                _error = error;
-                _result = result;
-                complete = true;
-              });
+          fs.stat('/mydirectorylink', function(error, result) {
+            expect(error).not.to.exist;
+            expect(result).to.exist;
+            expect(result['node']).to.equal(_node);
+            done();
           });
         });
       });
+    });
 
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
+    it('should follow a symbolic link to a directory', function(done) {
+      var fs = util.fs();
 
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
+      fs.mkdir('/mydir', function(error) {
+        fs.symlink('/mydir', '/mydirectorylink', function(error) {
+          if(error) throw error;
+
+          fs.stat('/mydir', function(error, result) {
+            if(error) throw error;
+
+            expect(result['node']).to.exist;
+            var _node = result['node'];
+            fs.stat('/mydirectorylink', function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.exist;
+              expect(result['node']).to.equal(_node);
+              done();
+            });
+          });
+        });
       });
     });
 
-    it('should follow a symbolic link to a file', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
+    it('should follow a symbolic link to a file', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile', function(error, result) {
+          fs.stat('/myfile', function(error, result) {
             if(error) throw error;
 
-            _node = result['node'];
-            that.fs.symlink('/myfile', '/myfilelink', function(error) {
+            expect(result['node']).to.exist;
+            var _node = result['node'];
+            fs.symlink('/myfile', '/myfilelink', function(error) {
               if(error) throw error;
 
-              that.fs.stat('/myfilelink', function(error, result) {
-                _error = error;
-                _result = result;
-                complete = true;
+              fs.stat('/myfilelink', function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).to.exist;
+                expect(result['node']).to.equal(_node);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
-      });
     });
 
-    it('should follow multiple symbolic links to a file', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
+    it('should follow multiple symbolic links to a file', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile', function(error, result) {
+          fs.stat('/myfile', function(error, result) {
             if(error) throw error;
 
-            _node = result['node'];
-            that.fs.symlink('/myfile', '/myfilelink1', function(error) {
+            expect(result['node']).to.exist;
+            var _node = result['node'];
+            fs.symlink('/myfile', '/myfilelink1', function(error) {
               if(error) throw error;
-              that.fs.symlink('/myfilelink1', '/myfilelink2', function(error) {
+              fs.symlink('/myfilelink1', '/myfilelink2', function(error) {
                 if(error) throw error;
 
-                that.fs.stat('/myfilelink2', function(error, result) {
-                  _error = error;
-                  _result = result;
-                  complete = true;
+                fs.stat('/myfilelink2', function(error, result) {
+                  expect(error).not.to.exist;
+                  expect(result).to.exist;
+                  expect(result['node']).to.equal(_node);
+                  done();
                 });
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
-      });
     });
 
-    it('should error if symbolic link leads to itself', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
+    it('should error if symbolic link leads to itself', function(done) {
+      var fs = util.fs();
 
-      that.fs.symlink('/mylink1', '/mylink2', function(error) {
+      fs.symlink('/mylink1', '/mylink2', function(error) {
         if(error) throw error;
 
-        that.fs.symlink('/mylink2', '/mylink1', function(error) {
+        fs.symlink('/mylink2', '/mylink1', function(error) {
           if(error) throw error;
 
-          that.fs.stat('/myfilelink1', function(error, result) {
-            _error = error;
-            _result = result;
-            complete = true;
+          fs.stat('/myfilelink1', function(error, result) {
+            expect(error).to.exist;
+            expect(result).not.to.exist;
+            done();
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
-      });
     });
 
-    it('should error if it follows more than 10 symbolic links', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should error if it follows more than 10 symbolic links', function(done) {
+      var fs = util.fs();
       var nlinks = 11;
 
       function createSymlinkChain(n, callback) {
@@ -201,104 +135,82 @@ define(["Filer"], function(Filer) {
           return callback();
         }
 
-        that.fs.symlink('/myfile' + (n-1), '/myfile' + n, createSymlinkChain.bind(this, n+1, callback));
+        fs.symlink('/myfile' + (n-1), '/myfile' + n, createSymlinkChain.bind(this, n+1, callback));
       }
 
-      that.fs.open('/myfile0', 'w', function(error, result) {
+      fs.open('/myfile0', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile0', function(error, result) {
+          fs.stat('/myfile0', function(error, result) {
             if(error) throw error;
 
             createSymlinkChain(1, function() {
-              that.fs.stat('/myfile11', function(error, result) {
-                _error = error;
-                _result = result;
-                complete = true;
+              fs.stat('/myfile11', function(error, result) {
+                expect(error).to.exist;
+                expect(error.name).to.equal('ELoop');
+                expect(result).not.to.exist;
+                done();
               });
             });
 
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).not.toBeDefined();
-        expect(_error).toBeDefined();
-        expect(_error.name).toEqual('ELoop');
-      });
     });
 
-    it('should follow a symbolic link in the path to a file', function() {
-      var complete = false;
-      var _error, _node, _result;
-      var that = this;
+    it('should follow a symbolic link in the path to a file', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile', function(error, result) {
+          fs.stat('/myfile', function(error, result) {
             if(error) throw error;
 
-            _node = result['node'];
-            that.fs.symlink('/', '/mydirlink', function(error) {
+            var _node = result['node'];
+            fs.symlink('/', '/mydirlink', function(error) {
               if(error) throw error;
 
-              that.fs.stat('/mydirlink/myfile', function(error, result) {
-                _error = error;
-                _result = result;
-                complete = true;
+              fs.stat('/mydirlink/myfile', function(error, result) {
+                expect(result).to.exist;
+                expect(error).not.to.exist;
+                expect(_node).to.exist;
+                expect(result['node']).to.equal(_node);
+                done();
               });
             });
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result).toBeDefined();
-        expect(_node).toBeDefined();
-        expect(_error).toEqual(null);
-        expect(_result['node']).toEqual(_node);
-      });
     });
 
-    it('should error if a symbolic link in the path to a file is itself a file', function() {
-      var complete = false;
-      var _error, _result;
-      var that = this;
+    it('should error if a symbolic link in the path to a file is itself a file', function(done) {
+      var fs = util.fs();
 
-      that.fs.open('/myfile', 'w', function(error, result) {
+      fs.open('/myfile', 'w', function(error, result) {
         if(error) throw error;
         var fd = result;
-        that.fs.close(fd, function(error) {
+        fs.close(fd, function(error) {
           if(error) throw error;
-          that.fs.stat('/myfile', function(error, result) {
+          fs.stat('/myfile', function(error, result) {
             if(error) throw error;
 
-            that.fs.open('/myfile2', 'w', function(error, result) {
+            fs.open('/myfile2', 'w', function(error, result) {
               if(error) throw error;
               var fd = result;
-              that.fs.close(fd, function(error) {
+              fs.close(fd, function(error) {
                 if(error) throw error;
-                that.fs.symlink('/myfile2', '/mynotdirlink', function(error) {
+                fs.symlink('/myfile2', '/mynotdirlink', function(error) {
                   if(error) throw error;
 
-                  that.fs.stat('/mynotdirlink/myfile', function(error, result) {
-                    _error = error;
-                    _result = result;
-                    complete = true;
+                  fs.stat('/mynotdirlink/myfile', function(error, result) {
+                    expect(error).to.exist;
+                    expect(result).not.to.exist;
+                    done();
                   });
                 });
               });
@@ -306,15 +218,6 @@ define(["Filer"], function(Filer) {
           });
         });
       });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_error).toBeDefined();
-        expect(_result).not.toBeDefined();
-      });
     });
   });
 

tests/spec/providers/providers.indexeddb.spec.js

@@ -1,189 +1,141 @@
-define(["Filer"], function(Filer) {
+define(["Filer", "util"], function(Filer, util) {
+
+  if(!Filer.FileSystem.providers.IndexedDB.isSupported()) {
+    console.log("Skipping Filer.FileSystem.providers.IndexedDB tests, since IndexedDB isn't supported.");
+    return;
+  }
 
   describe("Filer.FileSystem.providers.IndexedDB", function() {
     it("is supported -- if it isn't, none of these tests can run.", function() {
-      expect(Filer.FileSystem.providers.IndexedDB.isSupported()).toEqual(true);
+      expect(Filer.FileSystem.providers.IndexedDB.isSupported()).to.be.true;
     });
 
     it("has open, getReadOnlyContext, and getReadWriteContext instance methods", function() {
       var indexedDBProvider = new Filer.FileSystem.providers.IndexedDB();
-      expect(typeof indexedDBProvider.open).toEqual('function');
-      expect(typeof indexedDBProvider.getReadOnlyContext).toEqual('function');
-      expect(typeof indexedDBProvider.getReadWriteContext).toEqual('function');
+      expect(indexedDBProvider.open).to.be.a('function');
+      expect(indexedDBProvider.getReadOnlyContext).to.be.a('function');
+      expect(indexedDBProvider.getReadWriteContext).to.be.a('function');
     });
 
     describe("open an IndexedDB provider", function() {
+      var _provider;
+
       beforeEach(function() {
-        this.db_name = mk_db_name();
+        _provider = new util.providers.IndexedDB(util.uniqueName());
+        _provider.init();
       });
 
-      afterEach(function() {
-        indexedDB.deleteDatabase(this.db_name);
+      afterEach(function(done) {
+        _provider.cleanup(done);
+        _provider = null;
       });
 
-      it("should open a new IndexedDB database", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.IndexedDB(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
-          _result = firstAccess;
-          complete = true;
-        });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(true);
+      it("should open a new IndexedDB database", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          expect(error).not.to.exist;
+          expect(firstAccess).to.be.true;
+          done();
         });
       });
     });
 
     describe("Read/Write operations on an IndexedDB provider", function() {
+      var _provider;
+
       beforeEach(function() {
-        this.db_name = mk_db_name();
+        _provider = new util.providers.IndexedDB(util.uniqueName());
+        _provider.init();
       });
 
-      afterEach(function() {
-        indexedDB.deleteDatabase(this.db_name);
+      afterEach(function(done) {
+        _provider.cleanup(done);
+        _provider = null;
       });
 
-      it("should allow put() and get()", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.IndexedDB(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow put() and get()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.get("key", function(err, result) {
-              _error = _error || err;
-              _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-              complete = true;
+            context.get("key", function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.equal('value');
+              done();
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual("value");
-        });
       });
 
-      it("should allow delete()", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.IndexedDB(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow delete()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.delete("key", function(err, result) {
-              _error = _error || err;
-              context.get("key", function(err, result) {
-                _error = _error || err;
-                _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-                complete = true;
+            context.delete("key", function(error, result) {
+              if(error) throw error;
+
+              context.get("key", function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).not.to.exist;
+                done();
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(null);
-        });
       });
 
-      it("should allow clear()", function() {
-        var complete = false;
-        var _error, _result1, _result2;
-
-        var provider = new Filer.FileSystem.providers.IndexedDB(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow clear()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            context.put("key2", "value2", function(err, result) {
-              _error = _error || err;
+          context.put("key1", "value1", function(error, result) {
+            if(error) throw error;
+
+            context.put("key2", "value2", function(error, result) {
+              if(error) throw error;
 
               context.clear(function(err) {
-                _error = _error || err;
+                if(error) throw error;
 
-                context.get("key1", function(err, result) {
-                  _error = _error || err;
-                  _result1 = result;
+                context.get("key1", function(error, result) {
+                  if(error) throw error;
+                  expect(result).not.to.exist;
 
-                  context.get("key2", function(err, result) {
-                    _error = _error || err;
-                    _result2 = result;
-
-                    complete = true;
+                  context.get("key2", function(error, result) {
+                    if(error) throw error;
+                    expect(result).not.to.exist;
+                    done();
                   });
                 });
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result1).toEqual(null);
-          expect(_result2).toEqual(null);
-        });
       });
 
-      it("should fail when trying to write on ReadOnlyContext", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.IndexedDB(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should fail when trying to write on ReadOnlyContext", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadOnlyContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            _result = result;
-
-            complete = true;
+          context.put("key1", "value1", function(error, result) {
+            expect(error).to.exist;
+            expect(result).not.to.exist;
+            done();
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toBeDefined();
-          expect(_result).toEqual(null);
-        });
       });
     });
 

tests/spec/providers/providers.memory.spec.js

@@ -1,173 +1,112 @@
 define(["Filer"], function(Filer) {
-  
+
   describe("Filer.FileSystem.providers.Memory", function() {
     it("is supported -- if it isn't, none of these tests can run.", function() {
-      expect(Filer.FileSystem.providers.Memory.isSupported()).toEqual(true);
+      expect(Filer.FileSystem.providers.Memory.isSupported()).to.be.true;
     });
 
     it("has open, getReadOnlyContext, and getReadWriteContext instance methods", function() {
-      var indexedDBProvider = new Filer.FileSystem.providers.Memory();
-      expect(typeof indexedDBProvider.open).toEqual('function');
-      expect(typeof indexedDBProvider.getReadOnlyContext).toEqual('function');
-      expect(typeof indexedDBProvider.getReadWriteContext).toEqual('function');
+      var memoryProvider = new Filer.FileSystem.providers.Memory();
+      expect(memoryProvider.open).to.be.a('function');
+      expect(memoryProvider.getReadOnlyContext).to.be.a('function');
+      expect(memoryProvider.getReadWriteContext).to.be.a('function');
     });
 
     describe("open an Memory provider", function() {
-      it("should open a new Memory database", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.Memory(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
-          _result = firstAccess;
-          complete = true;
-        });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(true);
+      it("should open a new Memory database", function(done) {
+        var provider = new Filer.FileSystem.providers.Memory();
+        provider.open(function(error, firstAccess) {
+          expect(error).not.to.exist;
+          expect(firstAccess).to.be.true;
+          done();
         });
       });
     });
 
     describe("Read/Write operations on an Memory provider", function() {
-      it("should allow put() and get()", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.Memory(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow put() and get()", function(done) {
+        var provider = new Filer.FileSystem.providers.Memory();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.get("key", function(err, result) {
-              _error = _error || err;
-              _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-              complete = true;
+            context.get("key", function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.equal("value");
+              done();
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual("value");
-        });
       });
 
-      it("should allow delete()", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.Memory(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow delete()", function(done) {
+        var provider = new Filer.FileSystem.providers.Memory();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.delete("key", function(err, result) {
-              _error = _error || err;
-              context.get("key", function(err, result) {
-                _error = _error || err;
-                _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-                complete = true;
+            context.delete("key", function(error, result) {
+              if(error) throw error;
+
+              context.get("key", function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).not.to.exist;
+                done();
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(null);
-        });
       });
 
-      it("should allow clear()", function() {
-        var complete = false;
-        var _error, _result1, _result2;
-
-        var provider = new Filer.FileSystem.providers.Memory(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow clear()", function(done) {
+        var provider = new Filer.FileSystem.providers.Memory();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            context.put("key2", "value2", function(err, result) {
-              _error = _error || err;
+          context.put("key1", "value1", function(error, result) {
+            if(error) throw error;
+
+            context.put("key2", "value2", function(error, result) {
+              if(error) throw error;
 
               context.clear(function(err) {
-                _error = _error || err;
+                if(error) throw error;
 
-                context.get("key1", function(err, result) {
-                  _error = _error || err;
-                  _result1 = result;
+                context.get("key1", function(error, result) {
+                  if(error) throw error;
+                  expect(result).not.to.exist;
 
-                  context.get("key2", function(err, result) {
-                    _error = _error || err;
-                    _result2 = result;
-
-                    complete = true;
+                  context.get("key2", function(error, result) {
+                    if(error) throw error;
+                    expect(result).not.to.exist;
+                    done();
                   });
                 });
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result1).toEqual(null);
-          expect(_result2).toEqual(null);
-        });
       });
 
-      it("should fail when trying to write on ReadOnlyContext", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = new Filer.FileSystem.providers.Memory(this.db_name);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should fail when trying to write on ReadOnlyContext", function(done) {
+        var provider = new Filer.FileSystem.providers.Memory();
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadOnlyContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            _result = result;
-
-            complete = true;
+          context.put("key1", "value1", function(error, result) {
+            expect(error).to.exist;
+            expect(result).not.to.exist;
+            done();
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toBeDefined();
-          expect(_result).toEqual(null);
-        });
       });
     });
   });

tests/spec/providers/providers.spec.js

@@ -1,27 +1,27 @@
 define(["Filer"], function(Filer) {
   describe("Filer.FileSystem.providers", function() {
     it("is defined", function() {
-      expect(typeof Filer.FileSystem.providers).not.toEqual(undefined);
+      expect(Filer.FileSystem.providers).to.exist;
     });
 
     it("has IndexedDB constructor", function() {
-      expect(typeof Filer.FileSystem.providers.IndexedDB).toEqual('function');
+      expect(Filer.FileSystem.providers.IndexedDB).to.be.a('function');
     });
 
     it("has WebSQL constructor", function() {
-      expect(typeof Filer.FileSystem.providers.WebSQL).toEqual('function');
+      expect(Filer.FileSystem.providers.WebSQL).to.be.a('function');
     });
 
     it("has Memory constructor", function() {
-      expect(typeof Filer.FileSystem.providers.Memory).toEqual('function');
+      expect(Filer.FileSystem.providers.Memory).to.be.a('function');
     });
 
     it("has a Default constructor", function() {
-      expect(typeof Filer.FileSystem.providers.Default).toEqual('function');
+      expect(Filer.FileSystem.providers.Default).to.be.a('function');
     });
 
     it("has Fallback constructor", function() {
-      expect(typeof Filer.FileSystem.providers.Fallback).toEqual('function');
+      expect(Filer.FileSystem.providers.Fallback).to.be.a('function');
     });
   });
 });

tests/spec/providers/providers.websql.spec.js

@@ -1,15 +1,4 @@
-define(["Filer"], function(Filer) {
-
-  var WEBSQL_NAME = "websql-test-db";
-
-  function wipeDB(provider) {
-    var context = provider.getReadWriteContext();
-    context.clear(function(err) {
-      if(err) {
-        console.error("Problem clearing WebSQL db: [" + err.code + "] - " + err.message);
-      }
-    });
-  }
+define(["Filer", "util"], function(Filer, util) {
 
   if(!Filer.FileSystem.providers.WebSQL.isSupported()) {
     console.log("Skipping Filer.FileSystem.providers.WebSQL tests, since WebSQL isn't supported.");
@@ -18,183 +7,137 @@ define(["Filer"], function(Filer) {
 
   describe("Filer.FileSystem.providers.WebSQL", function() {
     it("is supported -- if it isn't, none of these tests can run.", function() {
-      expect(Filer.FileSystem.providers.WebSQL.isSupported()).toEqual(true);
+      expect(Filer.FileSystem.providers.WebSQL.isSupported()).to.be.true;
     });
 
     it("has open, getReadOnlyContext, and getReadWriteContext instance methods", function() {
       var webSQLProvider = new Filer.FileSystem.providers.WebSQL();
-      expect(typeof webSQLProvider.open).toEqual('function');
-      expect(typeof webSQLProvider.getReadOnlyContext).toEqual('function');
-      expect(typeof webSQLProvider.getReadWriteContext).toEqual('function');
+      expect(webSQLProvider.open).to.be.a('function');
+      expect(webSQLProvider.getReadOnlyContext).to.be.a('function');
+      expect(webSQLProvider.getReadWriteContext).to.be.a('function');
     });
 
     describe("open an WebSQL provider", function() {
-      afterEach(function() {
-        wipeDB(this.provider);
+      var _provider;
+
+      beforeEach(function() {
+        _provider = new util.providers.WebSQL(util.uniqueName());
+        _provider.init();
       });
 
-      it("should open a new WebSQL database", function() {
-        var complete = false;
-        var _error, _result;
+      afterEach(function(done) {
+        _provider.cleanup(done);
+        _provider = null;
+      });
 
-        var provider = this.provider = new Filer.FileSystem.providers.WebSQL(WEBSQL_NAME);
-        provider.open(function(err, firstAccess) {
-          _error = err;
-          _result = firstAccess;
-          complete = true;
-        });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(true);
+      it("should open a new WebSQL database", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          expect(error).not.to.exist;
+          expect(firstAccess).to.be.true;
+          done();
         });
       });
     });
 
     describe("Read/Write operations on an WebSQL provider", function() {
-      afterEach(function() {
-        wipeDB(this.provider);
+      var _provider;
+
+      beforeEach(function() {
+        _provider = new util.providers.WebSQL(util.uniqueName());
+        _provider.init();
       });
 
-      it("should allow put() and get()", function() {
-        var complete = false;
-        var _error, _result;
+      afterEach(function(done) {
+        _provider.cleanup(done);
+        _provider = null;
+      });
 
-        var provider = this.provider = new Filer.FileSystem.providers.WebSQL(WEBSQL_NAME);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow put() and get()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.get("key", function(err, result) {
-              _error = _error || err;
-              _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-              complete = true;
+            context.get("key", function(error, result) {
+              expect(error).not.to.exist;
+              expect(result).to.equal("value");
+              done();
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual("value");
-        });
       });
 
-      it("should allow delete()", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = this.provider = new Filer.FileSystem.providers.WebSQL(WEBSQL_NAME);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow delete()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key", "value", function(err, result) {
-            _error = _error || err;
-            context.delete("key", function(err, result) {
-              _error = _error || err;
-              context.get("key", function(err, result) {
-                _error = _error || err;
-                _result = result;
+          context.put("key", "value", function(error, result) {
+            if(error) throw error;
 
-                complete = true;
+            context.delete("key", function(error, result) {
+              if(error) throw error;
+
+              context.get("key", function(error, result) {
+                expect(error).not.to.exist;
+                expect(result).not.to.exist;
+                done();
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result).toEqual(null);
-        });
       });
 
-      it("should allow clear()", function() {
-        var complete = false;
-        var _error, _result1, _result2;
-
-        var provider = this.provider = new Filer.FileSystem.providers.WebSQL(WEBSQL_NAME);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should allow clear()", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadWriteContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            context.put("key2", "value2", function(err, result) {
-              _error = _error || err;
+          context.put("key1", "value1", function(error, result) {
+            if(error) throw error;
+
+            context.put("key2", "value2", function(error, result) {
+              if(error) throw error;
 
               context.clear(function(err) {
-                _error = _error || err;
+                if(error) throw error;
 
-                context.get("key1", function(err, result) {
-                  _error = _error || err;
-                  _result1 = result;
+                context.get("key1", function(error, result) {
+                  if(error) throw error;
+                  expect(result).not.to.exist;
 
-                  context.get("key2", function(err, result) {
-                    _error = _error || err;
-                    _result2 = result;
-
-                    complete = true;
+                  context.get("key2", function(error, result) {
+                    expect(error).not.to.exist;
+                    expect(result).not.to.exist;
+                    done();
                   });
                 });
               });
             });
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toEqual(null);
-          expect(_result1).toEqual(null);
-          expect(_result2).toEqual(null);
-        });
       });
 
-      it("should fail when trying to write on ReadOnlyContext", function() {
-        var complete = false;
-        var _error, _result;
-
-        var provider = this.provider = new Filer.FileSystem.providers.WebSQL(WEBSQL_NAME);
-        provider.open(function(err, firstAccess) {
-          _error = err;
+      it("should fail when trying to write on ReadOnlyContext", function(done) {
+        var provider = _provider.provider;
+        provider.open(function(error, firstAccess) {
+          if(error) throw error;
 
           var context = provider.getReadOnlyContext();
-          context.put("key1", "value1", function(err, result) {
-            _error = _error || err;
-            _result = result;
-
-            complete = true;
+          context.put("key1", "value1", function(error, result) {
+            expect(error).to.exist;
+            expect(result).not.to.exist;
+            done();
           });
         });
-
-        waitsFor(function() {
-          return complete;
-        }, 'test to complete', DEFAULT_TIMEOUT);
-
-        runs(function() {
-          expect(_error).toBeDefined();
-          expect(_result).toEqual(null);
-        });
       });
     });
-
   });
 
 });

tests/spec/regression/issue105.js

@@ -1,55 +0,0 @@
-define(["Filer"], function(Filer) {
-
- describe('trailing slashes in path names, issue 105', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
-
-    it('should deal with trailing slashes properly, path == path/', function() {
-      var complete = false;
-      var _result1, _result2;
-      var fs = this.fs;
-
-      fs.mkdir('/tmp', function(err) {
-        if(err) throw err;
-
-        fs.mkdir('/tmp/foo', function(err) {
-          if(err) throw err;
-
-          // Without trailing slash
-          fs.readdir('/tmp', function(err, result1) {
-            if(err) throw err;
-            _result1 = result1;
-
-            // With trailing slash
-            fs.readdir('/tmp/', function(err, result2) {
-              if(err) throw err;
-              _result2 = result2;
-
-              complete = true;
-            });
-          });
-        });
-      });
-
-      waitsFor(function() {
-        return complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_result1.length).toEqual(1);
-        expect(_result2[0]).toEqual('tmp');
-        expect(_result1).toEqual(_result2);
-      });
-    });
-  });
-});

tests/spec/regression/issue106.js

@@ -1,53 +0,0 @@
-define(["Filer"], function(Filer) {
-
-  describe('fs.writeFile truncation - issue 106', function() {
-    beforeEach(function() {
-      this.db_name = mk_db_name();
-      this.fs = new Filer.FileSystem({
-        name: this.db_name,
-        flags: 'FORMAT'
-      });
-    });
-
-    afterEach(function() {
-      indexedDB.deleteDatabase(this.db_name);
-      delete this.fs;
-    });
-
-    it('should truncate an existing file', function() {
-      var fs = this.fs;
-      var filename = '/test';
-      var _complete = false;
-      var _size1, _size2;
-
-      fs.writeFile(filename, '1', function(err) {
-        if(err) throw err;
-
-        fs.stat(filename, function(err, stats) {
-          if(err) throw err;
-          _size1 = stats.size;
-
-          fs.writeFile(filename, '', function(err) {
-            if(err) throw err;
-
-            fs.stat(filename, function(err, stats) {
-              if(err) throw err;
-              _size2 = stats.size;
-
-              _complete = true;
-            });
-          });
-        });
-      });
-
-      waitsFor(function() {
-        return _complete;
-      }, 'test to complete', DEFAULT_TIMEOUT);
-
-      runs(function() {
-        expect(_size1).toEqual(1);
-        expect(_size2).toEqual(0);
-      });
-    });
-  });
-});

tests/test-manifest.js

@@ -47,7 +47,7 @@ define([
   "spec/node-js/simple/test-fs-null-bytes",
 
   // Regressions, Bugs
-  "spec/regression/issue105",
-  "spec/regression/issue106"
+  "bugs/issue105",
+  "bugs/issue106"
 
 ]);

tools/jasmine-1.3.1/MIT.LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2008-2011 Pivotal Labs
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tools/jasmine-1.3.1/jasmine-html.js

@@ -1,681 +0,0 @@
-jasmine.HtmlReporterHelpers = {};
-
-jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
-  var el = document.createElement(type);
-
-  for (var i = 2; i < arguments.length; i++) {
-    var child = arguments[i];
-
-    if (typeof child === 'string') {
-      el.appendChild(document.createTextNode(child));
-    } else {
-      if (child) {
-        el.appendChild(child);
-      }
-    }
-  }
-
-  for (var attr in attrs) {
-    if (attr == "className") {
-      el[attr] = attrs[attr];
-    } else {
-      el.setAttribute(attr, attrs[attr]);
-    }
-  }
-
-  return el;
-};
-
-jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
-  var results = child.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.skipped) {
-    status = 'skipped';
-  }
-
-  return status;
-};
-
-jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
-  var parentDiv = this.dom.summary;
-  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
-  var parent = child[parentSuite];
-
-  if (parent) {
-    if (typeof this.views.suites[parent.id] == 'undefined') {
-      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
-    }
-    parentDiv = this.views.suites[parent.id].element;
-  }
-
-  parentDiv.appendChild(childElement);
-};
-
-
-jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
-  for(var fn in jasmine.HtmlReporterHelpers) {
-    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
-  }
-};
-
-jasmine.HtmlReporter = function(_doc) {
-  var self = this;
-  var doc = _doc || window.document;
-
-  var reporterView;
-
-  var dom = {};
-
-  // Jasmine Reporter Public Interface
-  self.logRunningSpecs = false;
-
-  self.reportRunnerStarting = function(runner) {
-    var specs = runner.specs() || [];
-
-    if (specs.length == 0) {
-      return;
-    }
-
-    createReporterDom(runner.env.versionString());
-    doc.body.appendChild(dom.reporter);
-    setExceptionHandling();
-
-    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
-    reporterView.addSpecs(specs, self.specFilter);
-  };
-
-  self.reportRunnerResults = function(runner) {
-    reporterView && reporterView.complete();
-  };
-
-  self.reportSuiteResults = function(suite) {
-    reporterView.suiteComplete(suite);
-  };
-
-  self.reportSpecStarting = function(spec) {
-    if (self.logRunningSpecs) {
-      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
-    }
-  };
-
-  self.reportSpecResults = function(spec) {
-    reporterView.specComplete(spec);
-  };
-
-  self.log = function() {
-    var console = jasmine.getGlobal().console;
-    if (console && console.log) {
-      if (console.log.apply) {
-        console.log.apply(console, arguments);
-      } else {
-        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
-      }
-    }
-  };
-
-  self.specFilter = function(spec) {
-    if (!focusedSpecName()) {
-      return true;
-    }
-
-    return spec.getFullName().indexOf(focusedSpecName()) === 0;
-  };
-
-  return self;
-
-  function focusedSpecName() {
-    var specName;
-
-    (function memoizeFocusedSpec() {
-      if (specName) {
-        return;
-      }
-
-      var paramMap = [];
-      var params = jasmine.HtmlReporter.parameters(doc);
-
-      for (var i = 0; i < params.length; i++) {
-        var p = params[i].split('=');
-        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
-      }
-
-      specName = paramMap.spec;
-    })();
-
-    return specName;
-  }
-
-  function createReporterDom(version) {
-    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
-      dom.banner = self.createDom('div', { className: 'banner' },
-        self.createDom('span', { className: 'title' }, "Jasmine "),
-        self.createDom('span', { className: 'version' }, version)),
-
-      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
-      dom.alert = self.createDom('div', {className: 'alert'},
-        self.createDom('span', { className: 'exceptions' },
-          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try/catch'),
-          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),
-      dom.results = self.createDom('div', {className: 'results'},
-        dom.summary = self.createDom('div', { className: 'summary' }),
-        dom.details = self.createDom('div', { id: 'details' }))
-    );
-  }
-
-  function noTryCatch() {
-    return window.location.search.match(/catch=false/);
-  }
-
-  function searchWithCatch() {
-    var params = jasmine.HtmlReporter.parameters(window.document);
-    var removed = false;
-    var i = 0;
-
-    while (!removed && i < params.length) {
-      if (params[i].match(/catch=/)) {
-        params.splice(i, 1);
-        removed = true;
-      }
-      i++;
-    }
-    if (jasmine.CATCH_EXCEPTIONS) {
-      params.push("catch=false");
-    }
-
-    return params.join("&");
-  }
-
-  function setExceptionHandling() {
-    var chxCatch = document.getElementById('no_try_catch');
-
-    if (noTryCatch()) {
-      chxCatch.setAttribute('checked', true);
-      jasmine.CATCH_EXCEPTIONS = false;
-    }
-    chxCatch.onclick = function() {
-      window.location.search = searchWithCatch();
-    };
-  }
-};
-jasmine.HtmlReporter.parameters = function(doc) {
-  var paramStr = doc.location.search.substring(1);
-  var params = [];
-
-  if (paramStr.length > 0) {
-    params = paramStr.split('&');
-  }
-  return params;
-}
-jasmine.HtmlReporter.sectionLink = function(sectionName) {
-  var link = '?';
-  var params = [];
-
-  if (sectionName) {
-    params.push('spec=' + encodeURIComponent(sectionName));
-  }
-  if (!jasmine.CATCH_EXCEPTIONS) {
-    params.push("catch=false");
-  }
-  if (params.length > 0) {
-    link += params.join("&");
-  }
-
-  return link;
-};
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);
-jasmine.HtmlReporter.ReporterView = function(dom) {
-  this.startedAt = new Date();
-  this.runningSpecCount = 0;
-  this.completeSpecCount = 0;
-  this.passedCount = 0;
-  this.failedCount = 0;
-  this.skippedCount = 0;
-
-  this.createResultsMenu = function() {
-    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
-      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
-      ' | ',
-      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
-
-    this.summaryMenuItem.onclick = function() {
-      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
-    };
-
-    this.detailsMenuItem.onclick = function() {
-      showDetails();
-    };
-  };
-
-  this.addSpecs = function(specs, specFilter) {
-    this.totalSpecCount = specs.length;
-
-    this.views = {
-      specs: {},
-      suites: {}
-    };
-
-    for (var i = 0; i < specs.length; i++) {
-      var spec = specs[i];
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
-      if (specFilter(spec)) {
-        this.runningSpecCount++;
-      }
-    }
-  };
-
-  this.specComplete = function(spec) {
-    this.completeSpecCount++;
-
-    if (isUndefined(this.views.specs[spec.id])) {
-      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
-    }
-
-    var specView = this.views.specs[spec.id];
-
-    switch (specView.status()) {
-      case 'passed':
-        this.passedCount++;
-        break;
-
-      case 'failed':
-        this.failedCount++;
-        break;
-
-      case 'skipped':
-        this.skippedCount++;
-        break;
-    }
-
-    specView.refresh();
-    this.refresh();
-  };
-
-  this.suiteComplete = function(suite) {
-    var suiteView = this.views.suites[suite.id];
-    if (isUndefined(suiteView)) {
-      return;
-    }
-    suiteView.refresh();
-  };
-
-  this.refresh = function() {
-
-    if (isUndefined(this.resultsMenu)) {
-      this.createResultsMenu();
-    }
-
-    // currently running UI
-    if (isUndefined(this.runningAlert)) {
-      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" });
-      dom.alert.appendChild(this.runningAlert);
-    }
-    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
-
-    // skipped specs UI
-    if (isUndefined(this.skippedAlert)) {
-      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" });
-    }
-
-    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.skippedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.skippedAlert);
-    }
-
-    // passing specs UI
-    if (isUndefined(this.passedAlert)) {
-      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" });
-    }
-    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
-
-    // failing specs UI
-    if (isUndefined(this.failedAlert)) {
-      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
-    }
-    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
-
-    if (this.failedCount === 1 && isDefined(dom.alert)) {
-      dom.alert.appendChild(this.failedAlert);
-      dom.alert.appendChild(this.resultsMenu);
-    }
-
-    // summary info
-    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
-    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
-  };
-
-  this.complete = function() {
-    dom.alert.removeChild(this.runningAlert);
-
-    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
-
-    if (this.failedCount === 0) {
-      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
-    } else {
-      showDetails();
-    }
-
-    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
-  };
-
-  return this;
-
-  function showDetails() {
-    if (dom.reporter.className.search(/showDetails/) === -1) {
-      dom.reporter.className += " showDetails";
-    }
-  }
-
-  function isUndefined(obj) {
-    return typeof obj === 'undefined';
-  }
-
-  function isDefined(obj) {
-    return !isUndefined(obj);
-  }
-
-  function specPluralizedFor(count) {
-    var str = count + " spec";
-    if (count > 1) {
-      str += "s"
-    }
-    return str;
-  }
-
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
-
-
-jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
-  this.spec = spec;
-  this.dom = dom;
-  this.views = views;
-
-  this.symbol = this.createDom('li', { className: 'pending' });
-  this.dom.symbolSummary.appendChild(this.symbol);
-
-  this.summary = this.createDom('div', { className: 'specSummary' },
-    this.createDom('a', {
-      className: 'description',
-      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),
-      title: this.spec.getFullName()
-    }, this.spec.description)
-  );
-
-  this.detail = this.createDom('div', { className: 'specDetail' },
-      this.createDom('a', {
-        className: 'description',
-        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
-        title: this.spec.getFullName()
-      }, this.spec.getFullName())
-  );
-};
-
-jasmine.HtmlReporter.SpecView.prototype.status = function() {
-  return this.getSpecStatus(this.spec);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
-  this.symbol.className = this.status();
-
-  switch (this.status()) {
-    case 'skipped':
-      break;
-
-    case 'passed':
-      this.appendSummaryToSuiteDiv();
-      break;
-
-    case 'failed':
-      this.appendSummaryToSuiteDiv();
-      this.appendFailureDetail();
-      break;
-  }
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
-  this.summary.className += ' ' + this.status();
-  this.appendToSummary(this.spec, this.summary);
-};
-
-jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
-  this.detail.className += ' ' + this.status();
-
-  var resultItems = this.spec.results().getItems();
-  var messagesDiv = this.createDom('div', { className: 'messages' });
-
-  for (var i = 0; i < resultItems.length; i++) {
-    var result = resultItems[i];
-
-    if (result.type == 'log') {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
-
-      if (result.trace.stack) {
-        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
-      }
-    }
-  }
-
-  if (messagesDiv.childNodes.length > 0) {
-    this.detail.appendChild(messagesDiv);
-    this.dom.details.appendChild(this.detail);
-  }
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
-  this.suite = suite;
-  this.dom = dom;
-  this.views = views;
-
-  this.element = this.createDom('div', { className: 'suite' },
-    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)
-  );
-
-  this.appendToSummary(this.suite, this.element);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.status = function() {
-  return this.getSpecStatus(this.suite);
-};
-
-jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
-  this.element.className += " " + this.status();
-};
-
-jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
-
-/* @deprecated Use jasmine.HtmlReporter instead
- */
-jasmine.TrivialReporter = function(doc) {
-  this.document = doc || document;
-  this.suiteDivs = {};
-  this.logRunningSpecs = false;
-};
-
-jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
-  var el = document.createElement(type);
-
-  for (var i = 2; i < arguments.length; i++) {
-    var child = arguments[i];
-
-    if (typeof child === 'string') {
-      el.appendChild(document.createTextNode(child));
-    } else {
-      if (child) { el.appendChild(child); }
-    }
-  }
-
-  for (var attr in attrs) {
-    if (attr == "className") {
-      el[attr] = attrs[attr];
-    } else {
-      el.setAttribute(attr, attrs[attr]);
-    }
-  }
-
-  return el;
-};
-
-jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
-  var showPassed, showSkipped;
-
-  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
-      this.createDom('div', { className: 'banner' },
-        this.createDom('div', { className: 'logo' },
-            this.createDom('span', { className: 'title' }, "Jasmine"),
-            this.createDom('span', { className: 'version' }, runner.env.versionString())),
-        this.createDom('div', { className: 'options' },
-            "Show ",
-            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
-            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
-            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
-            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
-            )
-          ),
-
-      this.runnerDiv = this.createDom('div', { className: 'runner running' },
-          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
-          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
-          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
-      );
-
-  this.document.body.appendChild(this.outerDiv);
-
-  var suites = runner.suites();
-  for (var i = 0; i < suites.length; i++) {
-    var suite = suites[i];
-    var suiteDiv = this.createDom('div', { className: 'suite' },
-        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
-        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
-    this.suiteDivs[suite.id] = suiteDiv;
-    var parentDiv = this.outerDiv;
-    if (suite.parentSuite) {
-      parentDiv = this.suiteDivs[suite.parentSuite.id];
-    }
-    parentDiv.appendChild(suiteDiv);
-  }
-
-  this.startedAt = new Date();
-
-  var self = this;
-  showPassed.onclick = function(evt) {
-    if (showPassed.checked) {
-      self.outerDiv.className += ' show-passed';
-    } else {
-      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
-    }
-  };
-
-  showSkipped.onclick = function(evt) {
-    if (showSkipped.checked) {
-      self.outerDiv.className += ' show-skipped';
-    } else {
-      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
-    }
-  };
-};
-
-jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
-  var results = runner.results();
-  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
-  this.runnerDiv.setAttribute("class", className);
-  //do it twice for IE
-  this.runnerDiv.setAttribute("className", className);
-  var specs = runner.specs();
-  var specCount = 0;
-  for (var i = 0; i < specs.length; i++) {
-    if (this.specFilter(specs[i])) {
-      specCount++;
-    }
-  }
-  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
-  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
-  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
-
-  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
-};
-
-jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
-  var results = suite.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.totalCount === 0) { // todo: change this to check results.skipped
-    status = 'skipped';
-  }
-  this.suiteDivs[suite.id].className += " " + status;
-};
-
-jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
-  if (this.logRunningSpecs) {
-    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
-  }
-};
-
-jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
-  var results = spec.results();
-  var status = results.passed() ? 'passed' : 'failed';
-  if (results.skipped) {
-    status = 'skipped';
-  }
-  var specDiv = this.createDom('div', { className: 'spec '  + status },
-      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
-      this.createDom('a', {
-        className: 'description',
-        href: '?spec=' + encodeURIComponent(spec.getFullName()),
-        title: spec.getFullName()
-      }, spec.description));
-
-
-  var resultItems = results.getItems();
-  var messagesDiv = this.createDom('div', { className: 'messages' });
-  for (var i = 0; i < resultItems.length; i++) {
-    var result = resultItems[i];
-
-    if (result.type == 'log') {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
-    } else if (result.type == 'expect' && result.passed && !result.passed()) {
-      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
-
-      if (result.trace.stack) {
-        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
-      }
-    }
-  }
-
-  if (messagesDiv.childNodes.length > 0) {
-    specDiv.appendChild(messagesDiv);
-  }
-
-  this.suiteDivs[spec.suite.id].appendChild(specDiv);
-};
-
-jasmine.TrivialReporter.prototype.log = function() {
-  var console = jasmine.getGlobal().console;
-  if (console && console.log) {
-    if (console.log.apply) {
-      console.log.apply(console, arguments);
-    } else {
-      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
-    }
-  }
-};
-
-jasmine.TrivialReporter.prototype.getLocation = function() {
-  return this.document.location;
-};
-
-jasmine.TrivialReporter.prototype.specFilter = function(spec) {
-  var paramMap = {};
-  var params = this.getLocation().search.substring(1).split('&');
-  for (var i = 0; i < params.length; i++) {
-    var p = params[i].split('=');
-    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
-  }
-
-  if (!paramMap.spec) {
-    return true;
-  }
-  return spec.getFullName().indexOf(paramMap.spec) === 0;
-};

tools/jasmine-1.3.1/jasmine.css

@@ -1,82 +0,0 @@
-body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
-
-#HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
-#HTMLReporter a { text-decoration: none; }
-#HTMLReporter a:hover { text-decoration: underline; }
-#HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; }
-#HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; }
-#HTMLReporter #jasmine_content { position: fixed; right: 100%; }
-#HTMLReporter .version { color: #aaaaaa; }
-#HTMLReporter .banner { margin-top: 14px; }
-#HTMLReporter .duration { color: #aaaaaa; float: right; }
-#HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; }
-#HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
-#HTMLReporter .symbolSummary li.passed { font-size: 14px; }
-#HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; }
-#HTMLReporter .symbolSummary li.failed { line-height: 9px; }
-#HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
-#HTMLReporter .symbolSummary li.skipped { font-size: 14px; }
-#HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; }
-#HTMLReporter .symbolSummary li.pending { line-height: 11px; }
-#HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; }
-#HTMLReporter .exceptions { color: #fff; float: right; margin-top: 5px; margin-right: 5px; }
-#HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
-#HTMLReporter .runningAlert { background-color: #666666; }
-#HTMLReporter .skippedAlert { background-color: #aaaaaa; }
-#HTMLReporter .skippedAlert:first-child { background-color: #333333; }
-#HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; }
-#HTMLReporter .passingAlert { background-color: #a6b779; }
-#HTMLReporter .passingAlert:first-child { background-color: #5e7d00; }
-#HTMLReporter .failingAlert { background-color: #cf867e; }
-#HTMLReporter .failingAlert:first-child { background-color: #b03911; }
-#HTMLReporter .results { margin-top: 14px; }
-#HTMLReporter #details { display: none; }
-#HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; }
-#HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
-#HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
-#HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
-#HTMLReporter.showDetails .summary { display: none; }
-#HTMLReporter.showDetails #details { display: block; }
-#HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
-#HTMLReporter .summary { margin-top: 14px; }
-#HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; }
-#HTMLReporter .summary .specSummary.passed a { color: #5e7d00; }
-#HTMLReporter .summary .specSummary.failed a { color: #b03911; }
-#HTMLReporter .description + .suite { margin-top: 0; }
-#HTMLReporter .suite { margin-top: 14px; }
-#HTMLReporter .suite a { color: #333333; }
-#HTMLReporter #details .specDetail { margin-bottom: 28px; }
-#HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; }
-#HTMLReporter .resultMessage { padding-top: 14px; color: #333333; }
-#HTMLReporter .resultMessage span.result { display: block; }
-#HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
-
-#TrivialReporter { padding: 8px 13px; position: absolute; top: 0; bottom: 0; left: 0; right: 0; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ }
-#TrivialReporter a:visited, #TrivialReporter a { color: #303; }
-#TrivialReporter a:hover, #TrivialReporter a:active { color: blue; }
-#TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; }
-#TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; }
-#TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; }
-#TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; }
-#TrivialReporter .runner.running { background-color: yellow; }
-#TrivialReporter .options { text-align: right; font-size: .8em; }
-#TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; }
-#TrivialReporter .suite .suite { margin: 5px; }
-#TrivialReporter .suite.passed { background-color: #dfd; }
-#TrivialReporter .suite.failed { background-color: #fdd; }
-#TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; }
-#TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; }
-#TrivialReporter .spec.failed { background-color: #fbb; border-color: red; }
-#TrivialReporter .spec.passed { background-color: #bfb; border-color: green; }
-#TrivialReporter .spec.skipped { background-color: #bbb; }
-#TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; }
-#TrivialReporter .passed { background-color: #cfc; display: none; }
-#TrivialReporter .failed { background-color: #fbb; }
-#TrivialReporter .skipped { color: #777; background-color: #eee; display: none; }
-#TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; }
-#TrivialReporter .resultMessage .mismatch { color: black; }
-#TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; }
-#TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; }
-#TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; }
-#TrivialReporter #jasmine_content { position: fixed; right: 100%; }
-#TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; }