/*global describe it before */

"use server";
"use mocha";

require("c9/inline-mocha")(module);

var expect = require('chai').expect;

describe('vfs-local', function () {
  this.timeout(5000);
  
  var root = __dirname + "/mock2/";
  var base = root.substr(0, root.length - 1);

  var vfs = require('vfs-lint')(require("vfs-local")({
    root: root,
    testing: true,
    defaultEnv: { CUSTOM: 43 },
    checkSymlinks: true
  }));

  var vfsLoose = require('vfs-lint')(require("vfs-local")({
    root: root
  }));

  var fs = require('fs');
  var child_process = require("child_process");
  if (!fs.existsSync) fs.existsSync = require('path').existsSync;
  
  describe('vfs.resolve()', function () {
    before(function(done){
      child_process.execFile("rm", ["-Rf", root], function(){
        child_process.execFile("cp", ["-a", __dirname + "/mock", root], function(err){
          if (err) throw err;
          
          done();
        });
      });
    });
    
    it('should prepend root when resolving virtual paths', function (done) {
      var vpath = "/dir/stuff.json";
      vfs.resolve(vpath, {}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("path").equals(base + vpath);
        done();
      });
    });
    it('should reject paths that resolve outside the root', function (done) {
      vfs.resolve("/../test-local.js", {}, function (err, meta) {
        expect(err).property("code").equals("EACCESS");
        done();
      });
    });
    it('should not prepend when already rooted', function (done) {
      var path = base + "/file.txt";
      vfs.resolve(path, { alreadyRooted: true }, function (err, meta) {
        if (err) throw err;
        expect(meta).property("path").equal(path);
        done();
      });
    });
    it('should error with ENOENT when the path is invalid', function (done) {
      vfs.resolve("/notexists.txt", {}, function (err, meta) {
        expect(err).property("code").equals("ENOENT");
        done();
      });
    });
    it('should not check fs when checkSymlinks is off', function (done) {
      var vpath = "/badpath.txt";
      vfsLoose.resolve(vpath, {}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("path").equal(base + vpath);
        done();
      });
    });
  });

  describe('vfs.stat()', function () {
    it('should return stat info for the text file', function (done) {
      vfs.stat("/file.txt", {}, function (err, stat) {
        if (err) throw err;
        expect(stat).property("name").equal("file.txt");
        expect(stat).property("size").equal(23);
        expect(stat).property("mime").equal("text/plain");
        done();
      });
    });
    it("should error with ENOENT when the file doesn't exist", function (done) {
      vfs.stat("/badfile.json", {}, function (err, stat) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
  });

  describe('vfs.readfile()', function () {
    it("should read the text file", function (done) {
      vfs.readfile("/file.txt", {}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("mime").equals("text/plain");
        expect(meta).property("size").equals(23);
        expect(meta).property("etag");
        expect(meta).property("stream").property("readable");
        var stream = meta.stream;
        var chunks = [];
        var length = 0;
        stream.on("data", function (chunk) {
          chunks.push(chunk);
          length += chunk.length;
        });
        stream.on("end", function () {
          expect(length).equal(23);
          var body = chunks.join("");
          expect(body).equal("This is a simple file!\n");
          done();
        });
      });
    });
    it("should error with ENOENT on missing files", function (done) {
      vfs.readfile("/badfile.json", {}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
    it("should error with EISDIR on directories", function (done) {
      vfs.readfile("/", {}, function (err, meta) {
        expect(err).property("code").equal("EISDIR");
        done();
      });
    });
    it("should support head requests", function (done) {
      vfs.readfile("/file.txt", {head:true}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("mime").equal("text/plain");
        expect(meta).property("size").equal(23);
        expect(meta).property("mime").ok;
        expect(meta.stream).not.ok;
        done();
      });
    });
    it("should support 304 via etags", function (done) {
      vfs.readfile("/file.txt", {head:true}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("etag").ok
        var etag = meta.etag;
        vfs.readfile("/file.txt", {etag:etag}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("mime").equal("text/plain");
          expect(meta).property("size").equal(23);
          expect(meta).property("notModified").ok;
          expect(meta.stream).not.ok;
          done();
        });
      });
    });
    it("should support range requests", function (done) {
      vfs.readfile("/file.txt", {range:{start:1,end:3}}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("mime").equal("text/plain");
        expect(meta).property("size").equal(3);
        expect(meta).property("etag").ok;
        expect(meta).property("partialContent").deep.equal({ start: 1, end: 3, size: 23 });
        expect(meta).property("stream").ok;
        var stream = meta.stream;
        var chunks = [];
        stream.on("data", function (chunk) {
          chunks.push(chunk);
        });
        stream.on("end", function () {
          var data = chunks.join("");
          expect(data).equal("his");
          done();
        });
      });
    });
    it("should support getting the last 10 bytes", function (done) {
      vfs.readfile("/file.txt", {range:{end:10},head:true}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("size").equal(10);
        expect(meta).property("etag").ok;
        expect(meta).property("partialContent").deep.equal({ start: 13, end: 22, size: 23 });
        done();
      });
    });
    it("should get rangeNotSatisfiable if start and end are both omitted", function (done) {
      vfs.readfile("/file.txt", {range:{}}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("rangeNotSatisfiable");
        done();
      });
    });
    it("should get rangeNotSatisfiable if start is after end", function (done) {
      vfs.readfile("/file.txt", {range:{start:5,end:4}}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("rangeNotSatisfiable");
        done();
      });
    });
  });

  describe('vfs.readdir()', function () {
    it("should read the directory", function (done) {
      vfs.readdir("/", {}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("etag");
        expect(meta).property("stream").property("readable");
        var stream = meta.stream;
        var parts = [];
        stream.on("data", function (part) {
          parts.push(part);
        });
        stream.on("end", function () {
          expect(parts).length(5);
          done();
        });
      });
    });
    it("should error with ENOENT when the folder doesn't exist", function (done) {
      vfs.readdir("/fake", {}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
    it("should error with ENOTDIR when the path is a file", function (done) {
      vfs.readdir("/file.txt", {}, function (err, meta) {
        expect(err).property("code").equal("ENOTDIR");
        done();
      });
    });
    it("should support head requests", function (done) {
      vfs.readdir("/", {head:true}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("etag").ok;
        expect(meta.stream).not.ok;
        done();
      });
    });
    it("should support 304 via etags", function (done) {
      vfs.readdir("/", {head:true}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("etag").ok;
        var etag = meta.etag;
        vfs.readdir("/", {etag:etag}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("notModified").ok;
          expect(meta.stream).not.ok;
          done();
        });
      });
    });
  });

  describe('vfs.mkfile()', function () {
    it("should create a file using using readable in options", function (done) {
      var stream = fs.createReadStream(__filename);
      var vpath = "/test.js";
      // Make sure the file doesn't exist.
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.mkfile(vpath, { stream: stream }, function (err, meta) {
        if (err) {
          fs.unlinkSync(base + vpath);
          return done(err);
        }
        var actual = fs.readFileSync(base + vpath, "utf8");
        var original = fs.readFileSync(__filename, "utf8");
        fs.unlinkSync(base + vpath);
        expect(actual).equal(original);
        done();
      });
    });
    it("should create a file using writable in callback", function (done) {
      var vpath = "/test.js";
      // Make sure the file doesn't exist.
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.mkfile(vpath, {}, function (err, meta) {
        if (err) {
          fs.unlinkSync(base + vpath);
          return done(err);
        }
        expect(meta).property("stream").property("writable").ok;
        var writable = meta.stream;
        var readable = fs.createReadStream(__filename);
        readable.pipe(writable);
        writable.on("close", function () {
          var actual = fs.readFileSync(base + vpath, "utf8");
          var original = fs.readFileSync(__filename, "utf8");
          fs.unlinkSync(base + vpath);
          expect(actual).equal(original);
          done();
        });
      });
    });
    it("should update an existing file using readble in options", function (done) {
      var vpath = "/changeme.txt";
      var stream = fs.createReadStream(__filename);
      fs.writeFileSync(base + vpath, "Original Content\n");
      vfs.mkfile(vpath, {stream: stream}, function (err, meta) {
        if (err) {
          fs.unlinkSync(base + vpath);
          return done(err);
        }
        var actual = fs.readFileSync(base + vpath, "utf8");
        var original = fs.readFileSync(__filename, "utf8");
        fs.unlinkSync(base + vpath);
        expect(actual).equal(original);
        done();
      });
    }),
    it("should update an existing file using writable in callback", function (done) {
      var vpath = "/changeme.txt";
      fs.writeFileSync(base + vpath, "Original Content\n");
      vfs.mkfile(vpath, {}, function (err, meta) {
        if (err) {
          fs.unlinkSync(base + vpath);
          return done(err);
        }
        expect(meta).property("stream").property("writable").ok;
        var writable = meta.stream;
        var readable = fs.createReadStream(__filename);
        readable.pipe(writable);
        writable.on("saved", function () {
          var actual = fs.readFileSync(base + vpath, "utf8");
          var original = fs.readFileSync(__filename, "utf8");
          fs.unlinkSync(base + vpath);
          expect(actual).equal(original);
          done();
        });
      });
    });
    it("should not write to a read only file", function(done) {
      var vpath = "/readonly.txt";
      fs.writeFileSync(base + vpath, "read only");
      fs.chmodSync(base + vpath, "0444");
      vfs.mkfile(vpath, {}, function(err, meta) {
        fs.unlinkSync(base + vpath);
        expect(err).property("code").equal("EACCES");
        done();
      });
    });
    it("should create intermediate directories", function(done) {
      vfs.execFile("rm", {args: ["-rf", root + "/nested"]}, function() {
        vfs.mkfile("/nested/dir/file.txt", { parents: true }, function(err, meta) {
          meta.stream.write("juhu");
          meta.stream.end();
          
          meta.stream.on("saved", function() {
            var contents = fs.readFileSync(root + "nested/dir/file.txt", "utf8");
            vfs.execFile("rm", {args: ["-rf", root + "/nested"]}, done);
            expect(contents).equal("juhu");
          });
        });
      });
    });
    it("should buffer in memory prior before writing", function(done) {
      var vpath = "/changeme.txt";
      var stream = fs.createReadStream(__filename);
      fs.writeFileSync(base + vpath, "Original Content\n");
      vfs.mkfile(vpath, {stream: stream, bufferWrite: true}, function (err, meta) {
        if (err) {
          fs.unlinkSync(base + vpath);
          return done(err);
        }
        var actual = fs.readFileSync(base + vpath, "utf8");
        var original = fs.readFileSync(__filename, "utf8");
        fs.unlinkSync(base + vpath);
        expect(actual).equal(original);
        done();
      });
    });
  });

  describe('vfs.mkdir()', function () {
    it("should create a directory", function (done) {
      var vpath = "/newdir";
      // Make sure it doesn't exist yet
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.mkdir(vpath, {}, function (err, meta) {
        if (err) {
          fs.rmdirSync(base + vpath);
          return done(err);
        }
        expect(fs.existsSync(base + vpath)).ok;
        fs.rmdirSync(base + vpath);
        done();
      });
    });
    it("should error with EEXIST when the directory already exists", function (done) {
      vfs.mkdir("/dir", {}, function (err, meta) {
        expect(err).property("code").equal("EEXIST");
        done();
      });
    });
    it("should error with EEXIST when a file already exists at the path", function (done) {
      vfs.mkdir("/file.txt", {}, function (err, meta) {
        expect(err).property("code").equal("EEXIST");
        done();
      });
    });
  });

  describe('vfs.rmfile()', function () {
    it("should delete a file", function (done) {
      var vpath = "/deleteme.txt";
      fs.writeFileSync(base + vpath, "DELETE ME!\n");
      expect(fs.existsSync(base + vpath)).ok;
      vfs.rmfile(vpath, {}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + vpath)).not.ok;
        done();
      });
    });
    it("should error with ENOENT if the file doesn't exist", function (done) {
      var vpath = "/badname.txt";
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.rmfile(vpath, {}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
    it("should error with EISDIR if the path is a directory", function (done) {
      var vpath = "/dir";
      expect(fs.existsSync(base + vpath)).ok;
      vfs.rmfile(vpath, {}, function (err, meta) {
        if (process.platform == "darwin")
          expect(err).property("code").equals("EPERM");
        else
          expect(err).property("code").equal("EISDIR");
        
        done();
      });
    });
  });

  describe('vfs.rmdir()', function () {
    it("should delete a directory", function (done) {
      var vpath = "/newdir";
      fs.mkdirSync(base + vpath);
      expect(fs.existsSync(base + vpath)).ok;
      vfs.rmdir(vpath, {}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + vpath)).not.ok;
        done();
      });
    });
    it("should error with ENOENT if the directory doesn't exist", function (done) {
      var vpath = "/baddir";
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.rmdir(vpath, {}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
    it("should error with ENOTDIR if the path is a file", function (done) {
      var vpath = "/file.txt";
      expect(fs.existsSync(base + vpath)).ok;
      vfs.rmdir(vpath, {}, function (err, meta) {
        expect(err).property("code").equal("ENOTDIR");
        done();
      });
    });
    it("should do recursive deletes if options.recursive is set", function (done) {
      fs.mkdirSync(base + "/foo");
      fs.writeFileSync(base + "/foo/bar.txt", "Hello");
      expect(fs.existsSync(base + "/foo")).ok;
      expect(fs.existsSync(base + "/foo/bar.txt")).ok;
      vfs.rmdir("/foo", {recursive:true}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + "/foo/bar.txt")).not.ok;
        expect(fs.existsSync(base + "/foo")).not.ok;
        done();
      });
    });
  });

  describe('vfs.rename()', function () {
    it("should rename a file using options.to", function (done) {
      var before = "/start.txt";
      var after = "/end.txt";
      var text = "Move me please\n";
      fs.writeFileSync(base + before, text);
      expect(fs.existsSync(base + before)).ok;
      expect(fs.existsSync(base + after)).not.ok;
      vfs.rename(before, {to: after}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + before)).not.ok;
        expect(fs.existsSync(base + after)).ok;
        expect(fs.readFileSync(base + after, "utf8")).equal(text);
        fs.unlinkSync(base + after);
        done();
      });
    });
    it("should rename a file using options.from", function (done) {
      var before = "/start.txt";
      var after = "/end.txt";
      var text = "Move me please\n";
      fs.writeFileSync(base + before, text);
      expect(fs.existsSync(base + before)).ok;
      expect(fs.existsSync(base + after)).not.ok;
      vfs.rename(after, {from: before}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + before)).not.ok;
        expect(fs.existsSync(base + after)).ok;
        expect(fs.readFileSync(base + after, "utf8")).equal(text);
        fs.unlinkSync(base + after);
        done();
      });
    });
    it("should error with ENOENT if the source doesn't exist", function (done) {
      vfs.rename("/notexist", {to:"/newname"}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
  });

  describe('vfs.copy()', function () {
    it("should copy a file using options.to", function (done) {
      var source = "/file.txt";
      var target = "/copy.txt";
      var text = fs.readFileSync(base + source, "utf8");
      vfs.copy(source, {to: target}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + target)).ok;
        expect(fs.readFileSync(base + target, "utf8")).equal(text);
        fs.unlinkSync(base + target);
        done();
      });
    });
    it("should copy a file using options.from", function (done) {
      var source = "/file.txt";
      var target = "/copy.txt";
      var text = fs.readFileSync(base + source, "utf8");
      vfs.copy(target, {from: source}, function (err, meta) {
        if (err) throw err;
        expect(fs.existsSync(base + target)).ok;
        expect(fs.readFileSync(base + target, "utf8")).equal(text);
        fs.unlinkSync(base + target);
        done();
      });
    });
    it("should error with ENOENT if the source doesn't exist", function (done) {
      vfs.copy("/badname.txt", {to:"/copy.txt"}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
  });

  describe('vfs.symlink()', function () {
    it("should create a symlink", function (done) {
      var target = "file.txt";
      var vpath = "/newlink.txt";
      var text = fs.readFileSync(root + target, "utf8");
      vfs.symlink(vpath, {target: target}, function (err, meta) {
        if (err) throw err;
        expect(fs.readFileSync(base + vpath, "utf8")).equal(text);
        fs.unlinkSync(base + vpath);
        done();
      });
    });
    it("should error with ENOENT if the dire3ctory of the target file does not exists", function (done) {
      vfs.symlink("/file.txt", {target:"/this/is/crazy"}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
    it("should error with EEXIST if the file already exists", function (done) {
      var target = "/target.txt";
      fs.writeFileSync(root + target, "Target");
      vfs.symlink("/file.txt", {target: target}, function (err, meta) {
        fs.unlinkSync(base + target);
        expect(err).property("code").equal("EEXIST");
        done();
      });
    });
  });

  describe('vfs.watch()', function () {
    it("should notice a directly watched file change (OS changing it)", function (done) {
      var vpath = "/newfile.txt";
      expect(fs.existsSync(base + vpath)).not.ok;
      fs.writeFile(base + vpath, "Test", function(){
        vfs.watch(vpath, {}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("watcher").ok;
          var watcher = meta.watcher;
          watcher.on("change", function listen(event, filename) {
            expect(event).equal(inner ? "delete" : "change");
            if (process.platform !== "darwin")
              expect(filename).equal(vpath.substr(1));
            
            if (inner) {
              watcher.close();
              done();
            }
          });
          
          var inner = false;
          fs.writeFile(base + vpath, "Change!", function(){
            setTimeout(function(){
              inner = true;
              fs.unlinkSync(base + vpath);
            }, 100);
          });
        });
      });
    });
    it("should notice a directly watched file change (change via VFS)", function (done) {
      var vpath = "/newfile.txt";
      expect(fs.existsSync(base + vpath)).not.ok;
      fs.writeFile(base + vpath, "Test", function(){
        vfs.watch(vpath, {}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("watcher").ok;
          var watcher = meta.watcher;
          watcher.on("change", function listen(event, filename) {
            if (process.platform !== "darwin")
              expect(filename).equal(vpath.substr(1));
            
            if (inner) {
              watcher.close();
              done();
            }
          });
          
          var inner = false;
          vfs.mkfile(vpath, {}, function(err, meta){
            var stream = meta.stream;
            stream.write("Change!");
            stream.end();
            setTimeout(function(){
              inner = true;
              fs.unlinkSync(base + vpath);
            }, 100);
          });
        });
      });
    });
    it("should notice a new file in a watched directory", function (done) {
      var vpath = "/newfile.txt";
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.watch("/", {}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("watcher").ok;
        var watcher = meta.watcher;
        watcher.on("change", function (event, filename) {
          watcher.close();
          expect(event).ok;
          if (process.platform !== "darwin")
            expect(filename).equal(vpath.substr(1));
          fs.unlinkSync(base + vpath);
          done();
        });
        fs.writeFileSync(base + vpath, "newfile!");
      });
    });
    it("should return error if path does not exist", function(done) {
      var vpath = "/newfile.txt";
      expect(fs.existsSync(base + vpath)).not.ok;
      vfs.watch(base + vpath, {file: false}, function (err, meta) {
        expect(err).ok;
        done();
      });
    });
  });

  describe('vfs.connect()', function () {
    var net = require('net');
    it("should connect to a tcp server and ping-pong", function (done) {
      var stream;
      var server = net.createServer(function (client) {
        client.setEncoding('utf8');
        client.once("data", function (chunk) {
          expect(chunk).equal("ping");
          stream.once("data", function (chunk) {
            expect(chunk).equal("pong");
            client.end();
            stream.end();
            server.close();
            done();
          });
          client.write("pong");
        });
      });
      server.listen(function () {
        var port = server.address().port;
        vfs.connect(port, {encoding:"utf8"}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("stream").ok;
          stream = meta.stream;
          stream.write("ping");
        });
      });
    });
  });

  describe('vfs.spawn()', function () {
    it("should spawn a child process", function (done) {
      var args = ["-e", "process.stdin.pipe(process.stdout);try{process.stdin.resume()}catch(e){};"];
      vfs.spawn(process.execPath, {args: args, stdoutEncoding: "utf8"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("process").ok;
        var child = meta.process;
        expect(child).property("stdout").ok;
        expect(child).property("stdin").ok;
        child.stdout.on("data", function (chunk) {
          expect(chunk).equal("echo me");
          child.stdout.on("end", function () {
            done();
          });
          child.stdin.end();
        });
        child.stdin.write("echo me");
      });
    });
    it("should have environment variables from process, fsOptions, and call", function (done) {
      process.env.PROCESS = 42;
      var args = ["-e", "console.log([process.env.PROCESS, process.env.CUSTOM, process.env.LOCAL].join(','))"];
      vfs.spawn(process.execPath, {args:args, stdoutEncoding: "utf8", stderrEncoding: "utf8", env: {LOCAL:44}}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("process").ok;
        var child = meta.process;
        var stdout = [];
        child.stdout.on("data", function (chunk) {
          stdout.push(chunk);
        });
        child.stdout.on("end", function () {
          stdout = stdout.join("");
          expect(stdout).equal("42,43,44\n");
          done();
        });
      });
    });
  });

  describe('vfs.execFile()', function () {
    it("should exec a child process", function (done) {
      var args = ["-p", "-e", "process.version"];
      vfs.execFile(process.execPath, {args:args}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("stdout").equal(process.version + "\n");
        expect(meta).property("stderr").equal("");
        done();
      });
    });
    it("should have environment variables from process, fsOptions, and call", function (done) {
      process.env.PROCESS = 42;
      var args = ["-e", "console.log([process.env.PROCESS, process.env.CUSTOM, process.env.LOCAL].join(','))"];
      vfs.execFile(process.execPath, {args:args, env: {LOCAL:44}}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("stdout").equal("42,43,44\n");
        done();
      });
    });
    it("should return stdout and stderr on the error object", function(done) {
      var args = ["-e", "console.error('error'); console.log('out'); process.exit(1);"];
      vfs.execFile(process.execPath, {args:args}, function (err, meta) {
        expect(err).property("stderr").equal("error\n");
        expect(err).property("stdout").equal("out\n");
        expect(err).property("code").equal(1);
        done();
      });
    });
  });

  describe('vfs.on(), vfs.off(), vfs.emit()', function () {
    it ("should register an event listener and catch an event", function (done) {
      vfs.on("myevent", onEvent, function (err) {
        if (err) throw err;
        vfs.emit("myevent", 42, function (err) {
          if (err) throw err;
        });
      });
      function onEvent(data) {
        expect(data).equal(42);
        vfs.off("myevent", onEvent, done);
      }
    });
    it("should catch multiple events of the same type", function (done) {
      var times = 0;
      vfs.on("myevent", onEvent, function (err) {
        if (err) throw err;
        vfs.emit("myevent", 43, function (err) {
          if (err) throw err;
        });
        vfs.emit("myevent", 43, function (err) {
          if (err) throw err;
        });
      });
      function onEvent(data) {
        expect(data).equal(43);
        if (++times === 2) {
          vfs.off("myevent", onEvent, done);
        }
      }
    });
    it("should call multiple listeners for a single event", function (done) {
      var times = 0;
      vfs.on("myevent", onEvent1, function (err) {
        if (err) throw err;
        vfs.on("myevent", onEvent2, function (err) {
          if (err) throw err;
          vfs.emit("myevent", 44, function (err) {
            if (err) throw err;
          });
        });
      });
      function onEvent1(data) {
        expect(data).equal(44);
        times++;
      }
      function onEvent2(data) {
        expect(data).equal(44);
        if (++times === 2) {
          vfs.off("myevent", onEvent1, function (err) {
            if (err) throw err;
            vfs.off("myevent", onEvent2, done);
          });
        }
      }
    });
    it("should stop listening after a handler is removed", function (done) {
      vfs.on("myevent", onEvent, function (err) {
        if (err) throw err;
        vfs.emit("myevent", 45, function (err) {
          if (err) throw err;
          vfs.off("myevent", onEvent, function (err) {
            if (err) throw err;
            vfs.emit("myevent", 46, done);
          });
        });
      });
      function onEvent(data) {
        expect(data).equal(45);
      }
    });
  });

  describe('vfs.extend()', function () {
    it("should extend using a local file", function (done) {
      vfs.extend("math", {file: __dirname + "/math.js"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        var api = meta.api;
        expect(api).property("add").a("function");
        expect(api).property("multiply").a("function");
        api.add(3, 4, function (err, result) {
          if (err) throw err;
          expect(result).equal(3 + 4);
          vfs.unextend("math", {}, done);
        });
      });
    });
    it("should extend using a string", function (done) {
      var code = fs.readFileSync(__dirname + "/math.js", "utf8");
      vfs.extend("math2", {code: code}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        var api = meta.api;
        expect(api).property("add").a("function");
        expect(api).property("multiply").a("function");
        api.add(3, 4, function (err, result) {
          if (err) throw err;
          expect(result).equal(3 + 4);
          vfs.unextend("math2", {}, done);
        });
      });
    });
    it("should extend using a stream", function (done) {
      var stream = fs.createReadStream(__dirname + "/math.js");
      vfs.extend("math3", {stream: stream}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        var api = meta.api;
        expect(api).property("add").a("function");
        expect(api).property("multiply").a("function");
        api.add(3, 4, function (err, result) {
          if (err) throw err;
          expect(result).equal(3 + 4);
          vfs.unextend("math3", {}, done);
        });
      });
    });
    it("should error with EEXIST if the same extension is added twice", function (done) {
      vfs.extend("math", {file: __dirname + "/math.js"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        vfs.extend("math", {file: __dirname + "/math.js"}, function (err, meta) {
          expect(err).property("code").equal("EEXIST");
          vfs.unextend("math", {}, done);
        });
      });
    });
    it("should allow a redefine if options.redefine is set", function (done) {
      vfs.extend("test", {file: __dirname + "/math.js"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        vfs.extend("test", {redefine: true, file: __dirname + "/math.js"}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("api").ok;
          vfs.unextend("test", {}, done);
        });
      });
    });
  });

  describe('vfs.unextend()', function () {
    it("should remove an extension", function (done) {
      vfs.extend("math7", {file: __dirname + "/math.js"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        vfs.use("math7", {}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("api").ok;
          vfs.unextend("math7", {}, function (err, meta) {
            if (err) throw err;
            vfs.use("math7", {}, function (err, meta) {
              expect(err).property("code").equal("ENOENT");
              done();
            });
          });
        });
      });
    });
  });

  describe('vfs.use()', function () {
    it("should load an existing api", function (done) {
      vfs.extend("math4", {file: __dirname + "/math.js"}, function (err, meta) {
        if (err) throw err;
        expect(meta).property("api").ok;
        vfs.use("math4", {}, function (err, meta) {
          if (err) throw err;
          expect(meta).property("api").ok;
          var api = meta.api;
          expect(api).property("add").a("function");
          expect(api).property("multiply").a("function");
          api.add(3, 4, function (err, result) {
            if (err) throw err;
            expect(result).equal(3 + 4);
            vfs.unextend("math4", {}, done);
          });
        });
      });
    });
    it("should error with ENOENT if the api doesn't exist", function (done) {
      vfs.use("notfound", {}, function (err, meta) {
        expect(err).property("code").equal("ENOENT");
        done();
      });
    });
  });

  describe('vfs sandboxing', function () {
    it("should sandbox stat", function (done) {
      vfs.stat("/stuff.json", { sandbox: "/dir" }, function (err, stat) {
        if (err) throw err;
        expect(stat).property("name").equal("stuff.json");
        done();
      });
    });
    it("should sandbox readfile", function (done) {
      vfs.readfile("/stuff.json", { sandbox: "/dir" }, function (err, meta) {
        if (err) throw err;
        expect(meta).property("stream").property("readable");
        done();
      });
    });
    it("should sandbox mkfile", function (done) {
      var vpath = "/test.js";
      var sandbox = "/dir";
      // Make sure the file doesn't exist.
      fs.unlink(base + sandbox + vpath, function(){
        expect(fs.existsSync(base + sandbox + vpath)).not.ok;
        vfs.mkfile(vpath, { sandbox: sandbox }, function (err, meta) {
          if (err) {
            fs.unlinkSync(base + sandbox + vpath);
            return done(err);
          }
          expect(meta).property("stream").property("writable").ok;
          var writable = meta.stream;
          writable.on("close", function () {
            expect(fs.existsSync(base + sandbox + vpath)).ok;
            fs.unlinkSync(base + sandbox + vpath);
            done();
          });
          writable.end("juhu");
        });
      });
    });
    it("should sandbox watcher events", function (done) {
      var vpath = "/newfile.txt";
      var sandbox = "/dir";
      fs.unlink(base + sandbox + vpath, function(){
        expect(fs.existsSync(base + sandbox + vpath)).not.ok;
        fs.writeFile(base + sandbox + vpath, "Test", function(){
          vfs.watch(vpath, { sandbox: sandbox }, function (err, meta) {
            if (err) throw err;
            var watcher = meta.watcher;
            watcher.on("change", function listen(event, filename) {
              if (process.platform !== "darwin")
                expect(filename).equal(vpath.substr(1));
              
              if (inner) {
                watcher.close();
                done();
              }
            });
            
            var inner = false;
            vfs.mkfile(vpath, { sandbox: sandbox }, function(err, meta){
              var stream = meta.stream;
              stream.write("Change!");
              stream.end();
              setTimeout(function(){
                inner = true;
                fs.unlinkSync(base + sandbox + vpath);
              }, 100);
            });
          });
        });
      });
    });
  });

});