fix #137

Author: silkentrance

package.json

@@ -25,14 +25,15 @@
     "os-tmpdir": "~1.0.2"
   },
   "devDependencies": {
-    "vows": "~0.7.0"
+    "vows": "~0.7.0",
+    "mocha": "~3.4.2"
   },
   "main": "lib/tmp.js",
   "files": [
     "lib/"
   ],
   "scripts": {
-    "test": "vows test/*-test.js",
+    "test": "vows test/legacy/*-test.js && mocha",
     "doc": "jsdoc -c .jsdoc.json"
   }
 }

test/assertions.js

@@ -0,0 +1,72 @@
+/* eslint-disable no-octal */
+
+var
+  assert = require('assert'),
+  fs = require('fs'),
+  path = require('path'),
+  existsSync = fs.existsSync || path.existsSync;
+
+
+module.exports.assertName = function assertName(name, expected) {
+  assert.ok(typeof name == 'string');
+  assert.ok(name.length > 0, 'an empty string is not a valid name');
+  if (expected) {
+    assert.equal(path.basename(name), expected, 'should be the expected name');
+  }
+};
+
+
+module.exports.assertStat = function assertStat(name, mode) {
+  var stat = fs.statSync(name);
+
+  /*
+  // geteuid() and getegid() do not exist on Windows.
+  // must use the effective gid and effective uid for testing
+  if (process.geteuid) {
+    assert.equal(stat.uid, process.geteuid(), 'should have the same UID');
+  }
+  if (process.getegid) {
+    // FIXME does not always work as expected (setgid bit on parent directory)
+    console.log('stat.gid ' + stat.gid);
+    console.log('egid ' + process.getegid());
+    assert.equal(stat.gid, process.getegid(), 'should have the same GUID');
+  }
+  */
+
+  // mode values do not work properly on Windows. Ignore “group” and
+  // “other” bits then. Ignore execute bit on that platform because it
+  // doesn’t exist—even for directories.
+  if (process.platform == 'win32') {
+    assert.equal(stat.mode & 000600, mode & 000600);
+  } else {
+    assert.equal(stat.mode & 000777, mode);
+  }
+};
+
+
+module.exports.assertPrefix = function assertPrefix(name, prefix) {
+  assert.equal(path.basename(name).slice(0, prefix.length), prefix, 'should have the provided prefix');
+};
+
+
+module.exports.assertPostfix = function assertPostfix(name, postfix) {
+  assert.equal(name.slice(name.length - postfix.length, name.length), postfix, 'should have the provided postfix');
+};
+
+
+module.exports.assertProperResult = function assertProperResult(result, withfd) {
+  assert.ok(result);
+  assert.ok(result.name, 'should have a name');
+  if (withfd) assert.ok(result.fd, 'should have an fd');
+  else assert.ok(result.fd == undefined, 'should not have an fd');
+  assert.ok(typeof result.removeCallback == 'function', 'should have a removeCallback');
+};
+
+
+module.exports.assertExists = function assertExists(name, isfile) {
+  assert.ok(existsSync(name), 'should exist');
+  var stat = fs.statSync(name);
+  if (isfile) assert.ok(stat.isFile(), 'should be a file');
+  else assert.ok(stat.isDirectory(), 'should be a directory');
+}
+

test/dir-sync-test.js

@@ -1,232 +1,46 @@
 /* eslint-disable no-octal */
+// vim: expandtab:ts=2:sw=2
 
 var
-  vows   = require('vows'),
   assert = require('assert'),
+  inbandStandardTests = require('./inband-standard.js'),
+  tmp = require('../lib/tmp.js');
+
+
+describe('tmp', function () {
+  describe('#dirSync()', function () {
+    // API call standard inband tests
+    describe('when running inband standard tests', function () {
+
+      inbandStandardTests(false, function before() {
+        this.topic = tmp.dirSync(this.opts);
+      });
+
+      describe('with invalid tries', function () {
+        it('should result in an error on negative tries', function () {
+          try {
+            tmp.dirSync({tries: -1});
+            assert.fail('should have failed');
+          } catch (err) {
+            assert.ok(err instanceof Error);
+          }
+        });
+      });
+    });
+
+    // API call issue specific inband tests
+    describe('when running issue specific inband tests', function () {
+      // add your issue specific tests here
+    });
+
+    // API call standard outband tests
+    describe('when running standard outband tests', function () {
+    });
+
+    // API call issue specific outband tests
+    describe('when running issue specific outband tests', function () {
+      // add your issue specific tests here
+    });
+  });
+});
 
-  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() {
-      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);