node_modules

8 files changed, 568 insertions, 0 deletions

diff --git a/node_modules/tmp/test/dir-sync-test.js b/node_modules/tmp/test/dir-sync-test.js
new file mode 100644
index 000000000..091a03e58
--- /dev/null
+++ b/node_modules/tmp/test/dir-sync-test.js
@@ -0,0 +1,230 @@
+var
+  vows   = require('vows'),
+  assert = require('assert'),
+
+  path       = require('path'),
+  fs         = require('fs'),
+  existsSync = fs.existsSync || path.existsSync,
+
+  tmp    = require('../lib/tmp.js'),
+  Test   = require('./base.js');
+
+
+function _testDir(mode) {
+  return function _testDirGenerated(result) {
+    assert.ok(existsSync(result.name), 'should exist');
+
+    var stat = fs.statSync(result.name);
+    assert.ok(stat.isDirectory(), 'should be a directory');
+
+    Test.testStat(stat, mode);
+  };
+}
+
+vows.describe('Synchronous directory creation').addBatch({
+  'when using without parameters': {
+    topic: function () {
+      return tmp.dirSync();
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040700),
+    'should have the default prefix': Test.testPrefixSync('tmp-')
+  },
+
+  'when using with prefix': {
+    topic: function () {
+      return tmp.dirSync({ prefix: 'something' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040700),
+    'should have the provided prefix': Test.testPrefixSync('something')
+  },
+
+  'when using with postfix': {
+    topic: function () {
+      return tmp.dirSync({ postfix: '.txt' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040700),
+    'should have the provided postfix': Test.testPostfixSync('.txt')
+  },
+
+  'when using template': {
+    topic: function () {
+      return tmp.dirSync({ template: path.join(tmp.tmpdir, 'clike-XXXXXX-postfix') });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040700),
+    'should have the provided prefix': Test.testPrefixSync('clike-'),
+    'should have the provided postfix': Test.testPostfixSync('-postfix')
+  },
+
+  'when using name': {
+    topic: function () {
+      return tmp.dirSync({ name: 'using-name' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should have the provided name': Test.testNameSync(path.join(tmp.tmpdir, 'using-name')),
+    'should be a directory': function (result) {
+      _testDir(040700)(result);
+      result.removeCallback();
+      assert.ok(!existsSync(result.name), 'Directory should be removed');
+    }
+  },
+
+  'when using multiple options': {
+    topic: function () {
+      return tmp.dirSync({ prefix: 'foo', postfix: 'bar', mode: 0750 });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040750),
+    'should have the provided prefix': Test.testPrefixSync('foo'),
+    'should have the provided postfix': Test.testPostfixSync('bar')
+  },
+
+  'when using multiple options and mode': {
+    topic: function () {
+      return tmp.dirSync({ prefix: 'complicated', postfix: 'options', mode: 0755 });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a directory': _testDir(040755),
+    'should have the provided prefix': Test.testPrefixSync('complicated'),
+    'should have the provided postfix': Test.testPostfixSync('options')
+  },
+
+  'no tries': {
+    topic: function () {
+      try {
+        return tmp.dirSync({ tries: -1 });
+      }
+      catch (e) {
+        return e;
+      }
+    },
+
+    'should return with an error': function (topic) {
+      assert.instanceOf(topic, Error);
+    }
+  },
+
+  'keep testing': {
+    topic: function () {
+      Test.testKeepSync('dir', '1', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should be a dir': function (err, name) {
+      _testDir(040700)({ name: name });
+      fs.rmdirSync(name);
+    }
+  },
+
+  'unlink testing': {
+    topic: function () {
+      Test.testKeepSync('dir', '0', this.callback);
+    },
+
+    'should not return with error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'Directory should be removed');
+    }
+  },
+
+  'non graceful testing': {
+    topic: function () {
+      Test.testGracefulSync('dir', '0', this.callback);
+    },
+
+    'should not return with error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should be a dir': function (err, name) {
+      _testDir(040700)({ name: name });
+      fs.rmdirSync(name);
+    }
+  },
+
+  'graceful testing': {
+    topic: function () {
+      Test.testGracefulSync('dir', '1', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'Directory should be removed');
+    }
+  },
+
+  'unsafeCleanup === true': {
+    topic: function () {
+      Test.testUnsafeCleanupSync('1', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'Directory should be removed');
+    },
+    'should remove symlinked dir': function(err, name) {
+      assert.ok(
+        !existsSync(name + '/symlinkme-target'),
+        'should remove target'
+      );
+    },
+    'should not remove contents of symlink dir': function(err, name) {
+      assert.ok(
+        existsSync(__dirname + '/symlinkme/file.js'),
+        'should not remove symlinked directory\'s content'
+      );
+    }
+  },
+
+  'unsafeCleanup === true with issue62 structure': {
+    topic: function () {
+      Test.testIssue62Sync(this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'Directory should be removed');
+    }
+  },
+
+  'unsafeCleanup === false': {
+    topic: function () {
+      Test.testUnsafeCleanupSync('0', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should be a directory': function (err, name) {
+       _testDir(040700)({name:name});
+      // make sure that everything gets cleaned up
+      fs.unlinkSync(path.join(name, 'should-be-removed.file'));
+      fs.unlinkSync(path.join(name, 'symlinkme-target'));
+      fs.rmdirSync(name);
+    }
+  },
+
+  'remove callback': {
+    topic: function () {
+      return tmp.dirSync();
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'removeCallback should remove directory': function (result) {
+      result.removeCallback();
+      assert.ok(!existsSync(result.name), 'Directory should be removed');
+    }
+  }
+}).exportTo(module);
diff --git a/node_modules/tmp/test/file-sync-test.js b/node_modules/tmp/test/file-sync-test.js
new file mode 100644
index 000000000..44c1d22f5
--- /dev/null
+++ b/node_modules/tmp/test/file-sync-test.js
@@ -0,0 +1,190 @@
+var
+  vows   = require('vows'),
+  assert = require('assert'),
+
+  path       = require('path'),
+  fs         = require('fs'),
+  existsSync = fs.existsSync || path.existsSync,
+
+  tmp    = require('../lib/tmp.js'),
+  Test   = require('./base.js');
+
+
+function _testFile(mode, fdTest) {
+  return function _testFileGenerated(result) {
+    assert.ok(existsSync(result.name), 'should exist');
+
+    var stat = fs.statSync(result.name);
+    assert.equal(stat.size, 0, 'should have zero size');
+    assert.ok(stat.isFile(), 'should be a file');
+
+    Test.testStat(stat, mode);
+
+    // check with fstat as well (fd checking)
+    if (fdTest) {
+      var fstat = fs.fstatSync(result.fd);
+      assert.deepEqual(fstat, stat, 'fstat results should be the same');
+
+      var data = new Buffer('something');
+      assert.equal(fs.writeSync(result.fd, data, 0, data.length, 0), data.length, 'should be writable');
+      assert.ok(!fs.closeSync(result.fd), 'should not return with error');
+    }
+  };
+}
+
+vows.describe('Synchronous file creation').addBatch({
+  'when using without parameters': {
+    topic: function () {
+      return tmp.fileSync();
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100600, true),
+    'should have the default prefix': Test.testPrefixSync('tmp-'),
+    'should have the default postfix': Test.testPostfixSync('.tmp')
+  },
+
+  'when using with prefix': {
+    topic: function () {
+      return tmp.fileSync({ prefix: 'something' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100600, true),
+    'should have the provided prefix': Test.testPrefixSync('something')
+  },
+
+  'when using with postfix': {
+    topic: function () {
+      return tmp.fileSync({ postfix: '.txt' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100600, true),
+    'should have the provided postfix': Test.testPostfixSync('.txt')
+  },
+
+  'when using template': {
+    topic: function () {
+      return tmp.fileSync({ template: path.join(tmp.tmpdir, 'clike-XXXXXX-postfix') });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100600, true),
+    'should have the provided prefix': Test.testPrefixSync('clike-'),
+    'should have the provided postfix': Test.testPostfixSync('-postfix')
+  },
+
+  'when using name': {
+    topic: function () {
+      return tmp.fileSync({ name: 'using-name.tmp' });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should have the provided name': Test.testNameSync(path.join(tmp.tmpdir, 'using-name.tmp')),
+    'should be a file': function (result) {
+      _testFile(0100600, true);
+      fs.unlinkSync(result.name);
+    }
+  },
+
+  'when using multiple options': {
+    topic: function () {
+      return tmp.fileSync({ prefix: 'foo', postfix: 'bar', mode: 0640 });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100640, true),
+    'should have the provided prefix': Test.testPrefixSync('foo'),
+    'should have the provided postfix': Test.testPostfixSync('bar')
+  },
+
+  'when using multiple options and mode': {
+    topic: function () {
+      return tmp.fileSync({ prefix: 'complicated', postfix: 'options', mode: 0644 });
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'should be a file': _testFile(0100644, true),
+    'should have the provided prefix': Test.testPrefixSync('complicated'),
+    'should have the provided postfix': Test.testPostfixSync('options')
+  },
+
+  'no tries': {
+    topic: function () {
+      try {
+        return tmp.fileSync({ tries: -1 });
+      }
+      catch (e) {
+        return e;
+      }
+    },
+
+    'should return with an error': function (topic) {
+        assert.instanceOf(topic, Error);
+    }
+  },
+
+  'keep testing': {
+    topic: function () {
+      Test.testKeepSync('file', '1', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should be a file': function (err, name) {
+      _testFile(0100600, false)({name:name});
+      fs.unlinkSync(name);
+    }
+  },
+
+  'unlink testing': {
+    topic: function () {
+      Test.testKeepSync('file', '0', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'File should be removed');
+    }
+  },
+
+  'non graceful testing': {
+    topic: function () {
+      Test.testGracefulSync('file', '0', this.callback);
+    },
+
+    'should not return with error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should be a file': function (err, name) {
+      _testFile(0100600, false)({name:name});
+      fs.unlinkSync(name);
+    }
+  },
+
+  'graceful testing': {
+    topic: function () {
+      Test.testGracefulSync('file', '1', this.callback);
+    },
+
+    'should not return with an error': assert.isNull,
+    'should return with a name': Test.assertName,
+    'should not exist': function (err, name) {
+      assert.ok(!existsSync(name), 'File should be removed');
+    }
+  },
+
+  'remove callback': {
+    topic: function () {
+      return tmp.fileSync();
+    },
+
+    'should return with a name': Test.assertNameSync,
+    'removeCallback should remove file': function (result) {
+      result.removeCallback();
+      assert.ok(!existsSync(result.name), 'File should be removed');
+    }
+  }
+
+}).exportTo(module);
diff --git a/node_modules/tmp/test/graceful-sync.js b/node_modules/tmp/test/graceful-sync.js
new file mode 100644
index 000000000..37766ffa6
--- /dev/null
+++ b/node_modules/tmp/test/graceful-sync.js
@@ -0,0 +1,20 @@
+var
+  tmp = require('../lib/tmp'),
+  spawn = require('./spawn-sync');
+
+var graceful = spawn.arg;
+
+if (graceful) {
+  tmp.setGracefulCleanup();
+}
+
+try {
+  var result = spawn.tmpFunction();
+  spawn.out(result.name, function () {
+    throw new Error('Thrown on purpose');
+  });
+}
+catch (e) {
+  spawn.err(e, spawn.exit);
+}
+
diff --git a/node_modules/tmp/test/issue62-sync.js b/node_modules/tmp/test/issue62-sync.js
new file mode 100644
index 000000000..94840c66d
--- /dev/null
+++ b/node_modules/tmp/test/issue62-sync.js
@@ -0,0 +1,27 @@
+
+var
+  fs    = require('fs'),
+  join  = require('path').join,
+  spawn = require('./spawn-sync');
+
+try {
+  var result = spawn.tmpFunction({ unsafeCleanup: true });
+  try {
+    // creates structure from issue 62
+    // https://github.com/raszi/node-tmp/issues/62
+
+    fs.mkdirSync(join(result.name, 'issue62'));
+
+    ['foo', 'bar'].forEach(function(subdir) {
+      fs.mkdirSync(join(result.name, 'issue62', subdir));
+      fs.writeFileSync(join(result.name, 'issue62', subdir, 'baz.txt'), '');
+    });
+
+    spawn.out(result.name, spawn.exit);
+  } catch (e) {
+    spawn.err(e.toString(), spawn.exit);
+  }
+}
+catch (e) {
+  spawn.err(e, spawn.exit);
+}
diff --git a/node_modules/tmp/test/issue62.js b/node_modules/tmp/test/issue62.js
new file mode 100644
index 000000000..004e19077
--- /dev/null
+++ b/node_modules/tmp/test/issue62.js
@@ -0,0 +1,27 @@
+var
+  fs    = require('fs'),
+  join  = require('path').join,
+  spawn = require('./spawn');
+
+spawn.tmpFunction({ unsafeCleanup: true }, function (err, name) {
+  if (err) {
+    spawn.err(err, spawn.exit);
+    return;
+  }
+
+  try {
+    // creates structure from issue 62
+    // https://github.com/raszi/node-tmp/issues/62
+
+    fs.mkdirSync(join(name, 'issue62'));
+
+    ['foo', 'bar'].forEach(function(subdir) {
+      fs.mkdirSync(join(name, 'issue62', subdir));
+      fs.writeFileSync(join(name, 'issue62', subdir, 'baz.txt'), '');
+    });
+
+    spawn.out(name, spawn.exit);
+  } catch (e) {
+    spawn.err(e.toString(), spawn.exit);
+  }
+});
diff --git a/node_modules/tmp/test/keep-sync.js b/node_modules/tmp/test/keep-sync.js
new file mode 100644
index 000000000..6cd8b186a
--- /dev/null
+++ b/node_modules/tmp/test/keep-sync.js
@@ -0,0 +1,12 @@
+var spawn = require('./spawn-sync');
+
+var keep = spawn.arg;
+
+try {
+  var result = spawn.tmpFunction({ keep: keep });
+  spawn.out(result.name, spawn.exit);
+}
+catch (e) {
+  spawn.err(err, spawn.exit);
+}
+
diff --git a/node_modules/tmp/test/spawn-sync.js b/node_modules/tmp/test/spawn-sync.js
new file mode 100644
index 000000000..bde2db469
--- /dev/null
+++ b/node_modules/tmp/test/spawn-sync.js
@@ -0,0 +1,32 @@
+var
+  fs = require('fs'),
+  tmp = require('../lib/tmp');
+
+function _writeSync(stream, str, cb) {
+  var flushed = stream.write(str);
+  if (flushed) {
+    return cb(null);
+  }
+
+  stream.once('drain', function _flushed() {
+    cb(null);
+  });
+}
+
+module.exports.out = function (str, cb) {
+  _writeSync(process.stdout, str, cb);
+};
+
+module.exports.err = function (str, cb) {
+  _writeSync(process.stderr, str, cb);
+};
+
+module.exports.exit = function () {
+  process.exit(0);
+};
+
+var type = process.argv[2];
+module.exports.tmpFunction = (type == 'file') ? tmp.fileSync : tmp.dirSync;
+
+var arg = (process.argv[3] && parseInt(process.argv[3], 10) === 1) ? true : false;
+module.exports.arg = arg;
diff --git a/node_modules/tmp/test/unsafe-sync.js b/node_modules/tmp/test/unsafe-sync.js
new file mode 100644
index 000000000..97717d05d
--- /dev/null
+++ b/node_modules/tmp/test/unsafe-sync.js
@@ -0,0 +1,30 @@
+var
+  fs    = require('fs'),
+  join  = require('path').join,
+  spawn = require('./spawn-sync');
+
+var unsafe = spawn.arg;
+
+try {
+  var result = spawn.tmpFunction({ unsafeCleanup: unsafe });
+  try {
+    // file that should be removed
+    var fd = fs.openSync(join(result.name, 'should-be-removed.file'), 'w');
+    fs.closeSync(fd);
+
+    // in tree source
+    var symlinkSource = join(__dirname, 'symlinkme');
+    // testing target
+    var symlinkTarget = join(result.name, 'symlinkme-target');
+
+    // symlink that should be removed but the contents should be preserved.
+    fs.symlinkSync(symlinkSource, symlinkTarget, 'dir');
+
+    spawn.out(result.name, spawn.exit);
+  } catch (e) {
+    spawn.err(e.toString(), spawn.exit);
+  }
+}
+catch (e) {
+  spawn.err(err, spawn.exit);
+}