chore(deps-dev): bump karma from 6.3.8 to 6.3.14

Bumps [karma](https://github.com/karma-runner/karma) from 6.3.8 to 6.3.14.
- [Release notes](https://github.com/karma-runner/karma/releases)
- [Changelog](https://github.com/karma-runner/karma/blob/master/CHANGELOG.md)
- [Commits](https://github.com/karma-runner/karma/compare/v6.3.8...v6.3.14)

---
updated-dependencies:
- dependency-name: karma
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.github/workflows/node-js-ci.yml

@@ -0,0 +1,27 @@
+name: node-js-ci
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: ['14', '16']
+
+    name: Node ${{ matrix.node }} on ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Test
+        uses: actions/setup-node@v2.4.1
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test

.gitignore

@@ -2,6 +2,7 @@ node_modules
 .env
 *~
 .vscode
+.idea
 
 # Parcel build dirs
 .cache

.release-it.json

@@ -1,18 +1,17 @@
 {
-  "scripts": {
-    "beforeStart": "npm run test",
-    "beforeBump": "npm run build",
-    "changelogCommand": "git log --pretty=format:'* %s (%h)' [REV_RANGE]"
+  "hooks": {
+    "before:init": ["npm run test"],
+    "before:bump": ["npm run build"]
   },
   "git": {
     "pushRepo": "git@github.com:filerjs/filer.git",
-    "tagName": "v%s"
+    "tagName": "v${version}"
   },
   "npm": {
     "publish": true
   },
   "github": {
-    "release": true,
-    "releaseName": "Filer.js %s Released"
+    "pushRepo": "git@github.com:filerjs/filer.git",
+    "release": true
   }
 }

AUTHORS

@@ -5,3 +5,5 @@ Barry Tulchinsky <barry.tulchinsky@gmail.com> (@btulchinsky)
 Kieran Sedgwick <kieran.sedgwick@gmail.com> (@sedge)
 Yoav Gurevich <ygurevich@ymail.com>
 Gideon Thomas <r.gideonthomas@gmail.com>
+Abdirahman Guled <aguled2@myseneca.ca>
+Ben Heidemann <ben@heidemann.co.uk>

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013, Alan Kligman
+Copyright (c) 2013 - 2019 Alan Kligman and the Filer contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

README.md

@@ -54,6 +54,78 @@ requirejs(['filer'], function(Filer) {...}
 var Filer = window.Filer;
 ```
 
+### Webpack Plugin
+
+Filer can be used as a drop-in replacement for the node.js [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. For convenience, filer provides a webpack plugin which
+will shim the desired node.js functionality. This plugin can be used by inserting the following into
+your webpack config:
+
+```javascript
+// webpack.config.js
+var { FilerWebpackPlugin } = require('filer/webpack');
+
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin(),
+  ],
+}
+```
+
+---
+**NOTE**
+
+Previously it was recommended to access the `FilerWebpackPlugin` class by importing the main filer module. This was depracated due [this issue](https://github.com/filerjs/filer/issues/790). For anyone using ***filer version 1.4.0 or earlier***, please import the plugin class like this:
+
+```javascript
+var FilerWebpackPlugin = require('filer/src/webpack-plugin');
+```
+
+---
+
+You can then import the node.js [fs](http://nodejs.org/api/fs.html) and [path](http://nodejs.org/api/path.html)
+modules as normal and `FilerWebpackPlugin` will ensure that webpack will resolve references to these modules to
+the appropriate filer shims. You will then be able to use these modules as normal (with the exception of the
+synchronous fs methods e.g. `mkdirSync()`).
+
+```javascript
+import fs from 'fs';
+import path from 'path';
+```
+
+The filer webpack plugin will, by default, shim the [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. However, it's behaviour can be customised by passing an
+options object.
+
+```javascript
+// webpack.config.js
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin({
+      // Options
+    }),
+  ],
+}
+```
+
+The following options can be passed to the filer webpack plugin:
+
+| Option        | Type    | Optional | Default                                          | Description                                                                                                                                      |
+|---------------|---------|----------|--------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| filerDir      | string  | yes      | '\<rootDir\>/node_modules/filer'                 | The directory in which filer is installed.                                                                                                       |
+| shimsDir      | string  | yes      | '\<rootDir\>/node_modules/filer/shims'           | The directory in which the shims are installed.                                                                                                  |
+| fsProviderDir | string  | yes      | '\<rootDir\>/node_modules/filer/shims/providers' | The directory in which the shims are located. This option is required when using a custom provider.                                              |
+| shimFs        | boolean | yes      | true                                             | Should the fs module be shimmed.                                                                                                                 |
+| shimPath      | boolean | yes      | true                                             | Should the path module be shimmed.                                                                                                               |
+| fsProvider    | string  | yes      | 'default'                                        | The file system provider to use. Should be one of 'default', 'indexeddb', 'memory', 'custom'. The 'default' option is equivalent to 'indexeddb'. |
+
+NOTE: '\<rootDir\>' will be resolved to the current working directory.
+
+Though filer also exposes the Buffer object, it is left up to the user to shim this as appropriate. This is because filer offers
+no custom implementation. Currently, filer uses the [node-libs-browser](https://github.com/webpack/node-libs-browser) Buffer implementation
+internally, though any faithful implementation of the [node.js Buffer object](http://nodejs.org/api/buffer.html) should play nicely
+with filer.
+
 ### Getting Started
 
 Filer is as close to the node.js [fs module](http://nodejs.org/api/fs.html) as possible,
@@ -788,7 +860,7 @@ fs.mkdtemp("/myDir/tmp", function (error, path) {
 });
 ```
 
-#### fs.readdir(path, callback)<a name="readdir"></a>
+#### fs.readdir(path, [options], callback)<a name="readdir"></a>
 
 Reads the contents of a directory. Asynchronous [readdir(3)](http://pubs.opengroup.org/onlinepubs/009695399/functions/readdir.html).
 Callback gets `(error, files)`, where `files` is an array containing the names of each directory entry (i.e., file, directory, link) in the directory, excluding `.` and `..`.
@@ -809,6 +881,12 @@ fs.readdir('/docs', function(err, files) {
 });
 ```
 
+Optionally accepts an options parameter, which can be either an encoding (e.g. "utf8") or an object with optional properties `encoding` and `withFileTypes`.
+
+The `encoding` property is a `string` which will determine the character encoding to use for the names of each directory entry. The `withFileTypes` property is a `boolean` which defaults to `false`. If `true`, this method will return an array of [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects.
+
+The `name` property on the [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects will be encoded using the specified character encoding.
+
 #### fs.close(fd, callback)<a name="close"></a>
 
 Closes a file descriptor. Asynchronous [close(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/close.html).

karma.conf.js

@@ -2,10 +2,14 @@ module.exports = function(config) {
   config.set({
     singleRun: true,
     basePath: '',
-    files: ['tests/dist/index.js'],
+    files: [
+      'node_modules/regenerator-runtime/runtime.js',
+      'tests/dist/index.js'
+    ],
     frameworks: ['mocha', 'chai'],
     reporters: ['mocha', 'summary'],
     client: {
+      captureConsole: true,
       mocha: {
         ui: 'bdd',
         timeout: 5000,

package.json

@@ -5,13 +5,12 @@
     "fs",
     "node",
     "file",
-    "system",
+    "filesystem",
     "browser",
     "indexeddb",
-    "idb",
-    "websql"
+    "idb"
   ],
-  "version": "1.1.0",
+  "version": "1.4.1",
   "author": "Alan K <ack@modeswitch.org> (http://blog.modeswitch.org)",
   "homepage": "http://filerjs.github.io/filer",
   "bugs": "https://github.com/filerjs/filer/issues",
@@ -46,36 +45,41 @@
     "url": "https://github.com/filerjs/filer.git"
   },
   "dependencies": {
-    "es6-promisify": "^6.0.1",
-    "minimatch": "^3.0.4"
+    "es6-promisify": "^7.0.0",
+    "minimatch": "^3.0.4",
+    "schema-utils": "^3.1.1"
   },
   "devDependencies": {
-    "chai": "^4.2.0",
-    "chai-datetime": "^1.5.0",
-    "eslint": "^5.10.0",
-    "karma": "^3.1.4",
+    "regenerator-runtime": "^0.13.9",
+    "chai": "^4.3.4",
+    "chai-datetime": "^1.8.0",
+    "eslint": "^7.32.0",
+    "fake-indexeddb": "^3.1.7",
+    "karma": "^6.3.8",
     "karma-chai": "^0.1.0",
-    "karma-chrome-launcher": "^2.2.0",
-    "karma-firefox-launcher": "^1.1.0",
-    "karma-mocha": "^1.3.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-mocha": "^2.0.1",
     "karma-mocha-reporter": "^2.2.5",
-    "karma-summary-reporter": "^1.5.2",
-    "meow": "^5.0.0",
-    "mocha": "^5.2.0",
-    "nyc": "^13.1.0",
-    "parcel-bundler": "^1.11.0",
-    "pretty-bytes": "^5.1.0",
-    "release-it": "^9.3.0",
+    "karma-summary-reporter": "^3.0.0",
+    "meow": "^10.0.1",
+    "mocha": "^9.1.3",
+    "nyc": "^15.1.0",
+    "parcel-bundler": "^1.12.5",
+    "pretty-bytes": "^5.6.0",
+    "release-it": "^14.11.6",
     "run.env": "^1.1.0",
-    "unused-filename": "^1.0.0",
-    "walk": "^2.3.14"
+    "unused-filename": "^3.0.1",
+    "walk": "^2.3.15"
   },
   "main": "./src/index.js",
   "browser": "./dist/filer.min.js",
   "files": [
     "src",
     "lib",
-    "dist"
+    "dist",
+    "shims",
+    "webpack"
   ],
   "nyc": {
     "exclude": [

shims/fs.js

@@ -0,0 +1,65 @@
+const { FileSystem } = require('../src/index');
+
+let Provider;
+try {
+  Provider = require('fsProvider');
+}
+catch (err) {
+  Provider = require('./providers/default');
+}
+
+const provider = new Provider();
+
+let onFsReady;
+let onFsError;
+
+let fsReady = new Promise((resolve, reject) => {
+  onFsReady = resolve;
+  onFsError = reject;
+});
+
+var fsInstance = new FileSystem({ provider }, (err) => {
+  if (err) {
+    onFsError(err);
+  } else {
+    onFsReady(true);
+  }
+});
+
+function proxyHasProp(target, prop) {
+  return prop in target;
+}
+
+const fsPromises = new Proxy(fsInstance.promises, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    return async (...args) => {
+      await fsReady;
+      return await target[prop](...args);
+    };
+  },
+});
+
+const fs = new Proxy(fsInstance, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    if (prop === 'promises') {
+      return fsPromises;
+    }
+
+    return (...args) => {
+      (async () => {
+        await fsReady;
+        target[prop](...args);
+      })();
+    };
+  },
+});
+
+module.exports = fs;

shims/path.js

@@ -0,0 +1,3 @@
+const { path } = require('../src/index');
+
+module.exports = path;

shims/providers/default.js

@@ -0,0 +1,2 @@
+const { Default } = require('../../src/providers/index');
+module.exports = Default;

shims/providers/indexeddb.js

@@ -0,0 +1,2 @@
+const IndexedDB = require('../../src/providers/indexeddb');
+module.exports = IndexedDB;

shims/providers/memory.js

@@ -0,0 +1,2 @@
+const Memory = require('../../src/providers/memory');
+module.exports = Memory;

src/dirent.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const Stats = require('./stats.js');
+
+function Dirent(path, fileNode, devName) {
+  this.constructor = Dirent;
+  Stats.call(this, path, fileNode, devName);
+}
+
+Dirent.prototype = Stats.prototype;
+
+module.exports = Dirent;

src/encoding.js

@@ -1,4 +0,0 @@
-module.exports = {
-  encode: string => Buffer.from(string),
-  decode: buffer => buffer.toString('utf8')
-};

src/filesystem/implementation.js

@@ -4,6 +4,7 @@ var dirname = Path.dirname;
 var basename = Path.basename;
 var isAbsolutePath = Path.isAbsolute;
 var shared = require('../shared.js');
+var async = require('../../lib/async.js');
 
 var Constants = require('../constants.js');
 var NODE_TYPE_FILE = Constants.NODE_TYPE_FILE;
@@ -29,13 +30,13 @@ var XATTR_REPLACE = Constants.XATTR_REPLACE;
 var FS_NOMTIME = Constants.FS_NOMTIME;
 var FS_NOCTIME = Constants.FS_NOCTIME;
 
-var Encoding = require('../encoding.js');
 var Errors = require('../errors.js');
 var DirectoryEntry = require('../directory-entry.js');
 var openFiles = require('../open-files.js');
 var OpenFileDescription = require('../open-file-description.js');
 var SuperNode = require('../super-node.js');
 var Node = require('../node.js');
+var Dirent = require('../dirent.js');
 var Stats = require('../stats.js');
 
 /**
@@ -228,7 +229,7 @@ function find_node(context, path, callback) {
     if(error) {
       callback(error);
     } else {
-      if(!parentDirectoryData.hasOwnProperty(name)) {
+      if(!Object.prototype.hasOwnProperty.call(parentDirectoryData, name)) {
         callback(new Errors.ENOENT(null, path));
       } else {
         var nodeId = parentDirectoryData[name].id;
@@ -294,10 +295,10 @@ function set_extended_attribute (context, path, node, name, value, flag, callbac
 
   var xattrs = node.xattrs;
 
-  if (flag === XATTR_CREATE && xattrs.hasOwnProperty(name)) {
+  if (flag === XATTR_CREATE && Object.prototype.hasOwnProperty.call(xattrs, name)) {
     callback(new Errors.EEXIST('attribute already exists', path));
   }
-  else if (flag === XATTR_REPLACE && !xattrs.hasOwnProperty(name)) {
+  else if (flag === XATTR_REPLACE && !Object.prototype.hasOwnProperty.call(xattrs, name)) {
     callback(new Errors.ENOATTR(null, path));
   }
   else {
@@ -479,7 +480,7 @@ function access_file(context, path, mode, callback) {
     }
 
     // In any other case, the file isn't accessible
-    callback(new Errors.EACCES('permission denied',path)) ; 
+    callback(new Errors.EACCES('permission denied',path)) ;
   });
 }
 
@@ -510,7 +511,7 @@ function remove_directory(context, path, callback) {
       callback(error);
     } else if(ROOT_DIRECTORY_NAME === name) {
       callback(new Errors.EBUSY(null, path));
-    } else if(!result.hasOwnProperty(name)) {
+    } else if(!Object.prototype.hasOwnProperty.call(result, name)) {
       callback(new Errors.ENOENT(null, path));
     } else {
       parentDirectoryData = result;
@@ -619,9 +620,9 @@ function open_file(context, path, flags, mode, callback) {
       callback(error);
     } else {
       directoryData = result;
-      if(directoryData.hasOwnProperty(name)) {
+      if(Object.prototype.hasOwnProperty.call(directoryData, name)) {
         if(flags.includes(O_EXCLUSIVE)) {
-          callback(new Errors.ENOENT('O_CREATE and O_EXCLUSIVE are set, and the named file exists', path));
+          callback(new Errors.EEXIST('O_CREATE and O_EXCLUSIVE are set, and the named file exists', path));
         } else {
           directoryEntry = directoryData[name];
           if(directoryEntry.type === NODE_TYPE_DIRECTORY && flags.includes(O_WRITE)) {
@@ -918,15 +919,22 @@ function lstat_file(context, path, callback) {
     }
   }
 
+  function create_node(error, data) {
+    if(error) {
+      return callback(error);
+    }
+    Node.create(data, callback);
+  }
+
   function check_if_file_exists(error, result) {
     if(error) {
       callback(error);
     } else {
       directoryData = result;
-      if(!directoryData.hasOwnProperty(name)) {
+      if(!Object.prototype.hasOwnProperty.call(directoryData, name)) {
         callback(new Errors.ENOENT('a component of the path does not name an existing file', path));
       } else {
-        context.getObject(directoryData[name].id, callback);
+        context.getObject(directoryData[name].id, create_node);
       }
     }
   }
@@ -980,7 +988,7 @@ function link_node(context, oldpath, newpath, callback) {
       callback(error);
     } else {
       newDirectoryData = result;
-      if(newDirectoryData.hasOwnProperty(newname)) {
+      if(Object.prototype.hasOwnProperty.call(newDirectoryData, newname)) {
         callback(new Errors.EEXIST('newpath resolves to an existing file', newname));
       } else {
         newDirectoryData[newname] = oldDirectoryData[oldname];
@@ -1004,7 +1012,7 @@ function link_node(context, oldpath, newpath, callback) {
       callback(error);
     } else {
       oldDirectoryData = result;
-      if(!oldDirectoryData.hasOwnProperty(oldname)) {
+      if(!Object.prototype.hasOwnProperty.call(oldDirectoryData, oldname)) {
         callback(new Errors.ENOENT('a component of either path prefix does not exist', oldname));
       } else if(oldDirectoryData[oldname].type === NODE_TYPE_DIRECTORY) {
         callback(new Errors.EPERM('oldpath refers to a directory'));
@@ -1071,7 +1079,7 @@ function unlink_node(context, path, callback) {
         context.putObject(fileNode.id, fileNode, function(error) {
           if(error) {
             callback(error);
-          } else {          
+          } else {
             update_node_times(context, path, fileNode, { ctime: Date.now() }, update_directory_data);
           }
         });
@@ -1094,7 +1102,7 @@ function unlink_node(context, path, callback) {
       callback(error);
     } else {
       directoryData = result;
-      if(!directoryData.hasOwnProperty(name)) {
+      if(!Object.prototype.hasOwnProperty.call(directoryData, name)) {
         callback(new Errors.ENOENT('a component of the path does not name an existing file', name));
       } else {
         context.getObject(directoryData[name].id, check_if_node_is_directory);
@@ -1114,26 +1122,72 @@ function unlink_node(context, path, callback) {
   find_node(context, parentPath, read_directory_data);
 }
 
-function read_directory(context, path, callback) {
+function read_directory(context, path, options, callback) {
   path = normalize(path);
 
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  options = validate_directory_options(options);
+
   var directoryNode;
   var directoryData;
 
   function handle_directory_data(error, result) {
-    if(error) {
+    if (error) {
       callback(error);
     } else {
       directoryData = result;
       var files = Object.keys(directoryData);
-      callback(null, files);
+
+      if (options.encoding) {
+        var fileBuffers = files.map(function (file) {
+          return Buffer.from(file);
+        });
+
+        if (options.encoding === 'buffer') {
+          files = fileBuffers;
+        }
+        else {
+          files = fileBuffers.map(function (fileBuffer) {
+            return fileBuffer.toString(options.encoding);
+          });
+        }
+      }
+
+      if (options.withFileTypes) {
+        var dirEnts = [];
+
+        // eslint-disable-next-line no-inner-declarations
+        function to_dir_entry(file, callback) {
+          const filename = Buffer.from(file, options.encoding).toString();
+          const filepath = Path.join(path, filename);
+          get_dir_entry(context, filepath, function(error, dirEnt) {
+            if (error) {
+              callback(error);
+            }
+            dirEnt.name = file;
+            dirEnts.push(dirEnt);
+            callback();
+          });
+        }
+
+        async.eachSeries(files, to_dir_entry, function (error) {
+          callback(error, dirEnts);
+        });
+      }
+
+      else {
+        callback(null, files);
+      }
     }
   }
 
   function read_directory_data(error, result) {
-    if(error) {
+    if (error) {
       callback(error);
-    } else if(result.type !== NODE_TYPE_DIRECTORY) {
+    } else if (result.type !== NODE_TYPE_DIRECTORY) {
       callback(new Errors.ENOTDIR(null, path));
     } else {
       directoryNode = result;
@@ -1144,6 +1198,30 @@ function read_directory(context, path, callback) {
   find_node(context, path, read_directory_data);
 }
 
+function get_dir_entry(context, path, callback) {
+  function check_result(error, result) {
+    if(error) {
+      callback(error);
+    } else {
+      var stats = new Dirent(path, result, context.name);
+      callback(null, stats);
+    }
+  }
+
+  lstat_file(context, path, check_result);
+}
+
+function validate_directory_options(options, enc) {
+  if (!options) {
+    options = { encoding: enc };
+  } else if (typeof options === 'function') {
+    options = { encoding: enc };
+  } else if (typeof options === 'string') {
+    options = { encoding: options };
+  }
+  return options;
+}
+
 function make_symbolic_link(context, srcpath, dstpath, callback) {
   dstpath = normalize(dstpath);
   var name = basename(dstpath);
@@ -1173,7 +1251,7 @@ function make_symbolic_link(context, srcpath, dstpath, callback) {
       callback(error);
     } else {
       directoryData = result;
-      if(directoryData.hasOwnProperty(name)) {
+      if(Object.prototype.hasOwnProperty.call(directoryData, name)) {
         callback(new Errors.EEXIST(null, name));
       } else {
         write_file_node();
@@ -1197,12 +1275,12 @@ function make_symbolic_link(context, srcpath, dstpath, callback) {
       // but store both versions, since we'll use the relative one in readlink().
       if(!isAbsolutePath(srcpath)) {
         fileNode.symlink_relpath = srcpath;
-        srcpath = Path.resolve(parentPath, srcpath); 
+        srcpath = Path.resolve(parentPath, srcpath);
       }
 
       fileNode.size = srcpath.length;
       fileNode.data = srcpath;
-      
+
       context.putObject(fileNode.id, fileNode, update_directory_data);
     });
   }
@@ -1250,7 +1328,7 @@ function read_link(context, path, callback) {
       callback(error);
     } else {
       directoryData = result;
-      if(!directoryData.hasOwnProperty(name)) {
+      if(!Object.prototype.hasOwnProperty.call(directoryData, name)) {
         callback(new Errors.ENOENT('a component of the path does not name an existing file', name));
       } else {
         context.getObject(directoryData[name].id, check_if_symbolic);
@@ -1489,7 +1567,7 @@ function getxattr_file (context, path, name, callback) {
 
     var xattrs = node.xattrs;
 
-    if (!xattrs.hasOwnProperty(name)) {
+    if (!Object.prototype.hasOwnProperty.call(xattrs, name)) {
       callback(new Errors.ENOATTR(null, path));
     }
     else {
@@ -1517,7 +1595,7 @@ function fgetxattr_file (context, ofd, name, callback) {
 
     var xattrs = node.xattrs;
 
-    if (!xattrs.hasOwnProperty(name)) {
+    if (!Object.prototype.hasOwnProperty.call(xattrs, name)) {
       callback(new Errors.ENOATTR());
     }
     else {
@@ -1554,7 +1632,7 @@ function removexattr_file (context, path, name, callback) {
 
     var xattrs = node.xattrs;
 
-    if (!xattrs.hasOwnProperty(name)) {
+    if (!Object.prototype.hasOwnProperty.call(xattrs, name)) {
       callback(new Errors.ENOATTR(null, path));
     }
     else {
@@ -1591,7 +1669,7 @@ function fremovexattr_file (context, ofd, name, callback) {
 
     var xattrs = node.xattrs;
 
-    if (!xattrs.hasOwnProperty(name)) {
+    if (!Object.prototype.hasOwnProperty.call(xattrs, name)) {
       callback(new Errors.ENOATTR());
     }
     else {
@@ -1612,7 +1690,7 @@ function fremovexattr_file (context, ofd, name, callback) {
 }
 
 function validate_flags(flags) {
-  return O_FLAGS.hasOwnProperty(flags) ? O_FLAGS[flags] : null;
+  return Object.prototype.hasOwnProperty.call(O_FLAGS, flags) ? O_FLAGS[flags] : null;
 }
 
 function validate_file_options(options, enc, fileMode){
@@ -1680,7 +1758,7 @@ function mkdir(context, path, mode, callback) {
     mode = validateAndMaskMode(mode, FULL_READ_WRITE_EXEC_PERMISSIONS, callback);
     if(!mode) return;
   }
- 
+
   make_directory(context, path, callback);
 }
 
@@ -1698,14 +1776,14 @@ function mkdtemp(context, prefix, options, callback) {
   callback = arguments[arguments.length - 1];
   if(!prefix) {
     return callback(new Error('filename prefix is required'));
-  } 
+  }
 
   let random = shared.randomChars(6);
-  var path = prefix + '-' + random; 
+  var path = prefix + '-' + random;
 
   make_directory(context, path, function(error) {
     callback(error, path);
-  });  
+  });
 }
 
 function rmdir(context, path, callback) {
@@ -1827,7 +1905,7 @@ function readFile(context, path, options, callback) {
 
         var data;
         if(options.encoding === 'utf8') {
-          data = Encoding.decode(buffer);
+          data = buffer.toString('utf8');
         } else {
           data = buffer;
         }
@@ -1863,12 +1941,17 @@ function writeFile(context, path, data, options, callback) {
     return callback(new Errors.EINVAL('flags is not valid', path));
   }
 
-  data = data || '';
-  if(typeof data === 'number') {
-    data = '' + data;
-  }
-  if(typeof data === 'string' && options.encoding === 'utf8') {
-    data = Encoding.encode(data);
+  if(!Buffer.isBuffer(data)) {
+    if(typeof data === 'number') {
+      data = '' + data;
+    }
+    data = data || '';
+    if(typeof data !== 'string') {
+      data = Buffer.from(data.toString());
+    }
+    else {
+      data = Buffer.from(data || '', options.encoding || 'utf8');
+    }
   }
 
   open_file(context, path, flags, function(err, fileNode) {
@@ -1903,7 +1986,7 @@ function appendFile(context, path, data, options, callback) {
     data = '' + data;
   }
   if(typeof data === 'string' && options.encoding === 'utf8') {
-    data = Encoding.encode(data);
+    data = Buffer.from(data);
   }
 
   open_file(context, path, flags, function(err, fileNode) {
@@ -2152,8 +2235,8 @@ function lseek(context, fd, offset, whence, callback) {
   }
 }
 
-function readdir(context, path, callback) {
-  read_directory(context, path, callback);
+function readdir(context, path, options, callback) {
+  read_directory(context, path, options, callback);
 }
 
 function toUnixTimestamp(time) {
@@ -2161,7 +2244,7 @@ function toUnixTimestamp(time) {
     return time;
   }
   if (typeof time === 'object' && typeof time.getTime === 'function') {
-    return time.getTime() / 1000;
+    return time.getTime();
   }
 }
 
@@ -2243,7 +2326,7 @@ function rename(context, oldpath, newpath, callback) {
   newpath = normalize(newpath);
 
   var oldParentPath = Path.dirname(oldpath);
-  var newParentPath = Path.dirname(oldpath);
+  var newParentPath = Path.dirname(newpath);
   var oldName = Path.basename(oldpath);
   var newName = Path.basename(newpath);
   var oldParentDirectory, oldParentData;
@@ -2294,7 +2377,7 @@ function rename(context, oldpath, newpath, callback) {
       callback(error);
     } else {
       newParentData = result;
-      if(newParentData.hasOwnProperty(newName)) {
+      if(Object.prototype.hasOwnProperty.call(newParentData, newName)) {
         remove_directory(context, newpath, update_new_parent_directory_data);
       } else {
         update_new_parent_directory_data();

src/filesystem/interface.js

@@ -1,38 +1,43 @@
-var { promisify } = require('es6-promisify');
+'use strict';
 
-var Path = require('../path.js');
-var nop = require('../shared.js').nop;
+const { promisify } = require('es6-promisify');
 
-var Constants = require('../constants.js');
-var FILE_SYSTEM_NAME = Constants.FILE_SYSTEM_NAME;
-var FS_FORMAT = Constants.FS_FORMAT;
-var FS_READY = Constants.FS_READY;
-var FS_PENDING = Constants.FS_PENDING;
-var FS_ERROR = Constants.FS_ERROR;
-var FS_NODUPEIDCHECK = Constants.FS_NODUPEIDCHECK;
+const Path = require('../path.js');
 
-var providers = require('../providers/index.js');
+const providers = require('../providers/index.js');
 
-var Shell = require('../shell/shell.js');
-var Intercom = require('../../lib/intercom.js');
-var FSWatcher = require('../fs-watcher.js');
-var Errors = require('../errors.js');
-var defaultGuidFn = require('../shared.js').guid;
+const Shell = require('../shell/shell.js');
+const Intercom = require('../../lib/intercom.js');
+const FSWatcher = require('../fs-watcher.js');
+const Errors = require('../errors.js');
+const {
+  nop,
+  guid: defaultGuidFn
+} = require('../shared.js');
 
-var STDIN = Constants.STDIN;
-var STDOUT = Constants.STDOUT;
-var STDERR = Constants.STDERR;
+const {
+  fsConstants,
+  FILE_SYSTEM_NAME,
+  FS_FORMAT,
+  FS_READY,
+  FS_PENDING,
+  FS_ERROR,
+  FS_NODUPEIDCHECK,
+  STDIN,
+  STDOUT,
+  STDERR
+} = require('../constants.js');
 
 // The core fs operations live on impl
-var impl = require('./implementation.js');
+const impl = require('./implementation.js');
 
 // node.js supports a calling pattern that leaves off a callback.
 function maybeCallback(callback) {
-  if(typeof callback === 'function') {
+  if (typeof callback === 'function') {
     return callback;
   }
-  return function(err) {
-    if(err) {
+  return function (err) {
+    if (err) {
       throw err;
     }
   };
@@ -40,7 +45,7 @@ function maybeCallback(callback) {
 
 // Default callback that logs an error if passed in
 function defaultCallback(err) {
-  if(err) {
+  if (err) {
     /* eslint no-console: 0 */
     console.error('Filer error: ', err);
   }
@@ -48,20 +53,20 @@ function defaultCallback(err) {
 // Get a path (String) from a file:// URL. Support URL() like objects
 // https://github.com/nodejs/node/blob/968e901aff38a343b1de4addebf79fd8fa991c59/lib/internal/url.js#L1381
 function toPathIfFileURL(fileURLOrPath) {
-  if(!(fileURLOrPath &&
-       fileURLOrPath.protocol &&
-       fileURLOrPath.pathname)) {
+  if (!(fileURLOrPath &&
+    fileURLOrPath.protocol &&
+    fileURLOrPath.pathname)) {
     return fileURLOrPath;
   }
 
-  if(fileURLOrPath.protocol !== 'file:') {
+  if (fileURLOrPath.protocol !== 'file:') {
     throw new Errors.EINVAL('only file: URLs are supported for paths', fileURLOrPath);
   }
 
-  var pathname = fileURLOrPath.pathname;
-  for (var n = 0; n < pathname.length; n++) {
+  const pathname = fileURLOrPath.pathname;
+  for (let n = 0; n < pathname.length; n++) {
     if (pathname[n] === '%') {
-      var third = pathname.codePointAt(n + 2) | 0x20;
+      const third = pathname.codePointAt(n + 2) | 0x20;
       if (pathname[n + 1] === '2' && third === 102) {
         throw new Errors.EINVAL('file: URLs must not include encoded / characters', fileURLOrPath);
       }
@@ -77,23 +82,23 @@ function toPathIfBuffer(bufferOrPath) {
 }
 
 function validatePath(path, allowRelative) {
-  if(!path) {
+  if (!path) {
     return new Errors.EINVAL('Path must be a string', path);
-  } else if(Path.isNull(path)) {
+  } else if (Path.isNull(path)) {
     return new Errors.EINVAL('Path must be a string without null bytes.', path);
-  } else if(!allowRelative && !Path.isAbsolute(path)) {
+  } else if (!allowRelative && !Path.isAbsolute(path)) {
     return new Errors.EINVAL('Path must be absolute.', path);
   }
 }
 
 function processPathArg(args, idx, allowRelative) {
-  var path = args[idx];
+  let path = args[idx];
   path = toPathIfFileURL(path);
   path = toPathIfBuffer(path);
 
   // Some methods specifically allow for rel paths (eg symlink with srcPath)
-  var err = validatePath(path, allowRelative);
-  if(err) {
+  let err = validatePath(path, allowRelative);
+  if (err) {
     throw err;
   }
 
@@ -133,14 +138,14 @@ function FileSystem(options, callback) {
   options = options || {};
   callback = callback || defaultCallback;
 
-  var flags = options.flags || [];
-  var guid = options.guid ? options.guid : defaultGuidFn;
-  var provider = options.provider || new providers.Default(options.name || FILE_SYSTEM_NAME);
+  const flags = options.flags || [];
+  const guid = options.guid ? options.guid : defaultGuidFn;
+  const provider = options.provider || new providers.Default(options.name || FILE_SYSTEM_NAME);
   // If we're given a provider, match its name unless we get an explicit name
-  var name = options.name || provider.name;
-  var forceFormatting = flags.includes(FS_FORMAT);
+  const name = options.name || provider.name;
+  const forceFormatting = flags.includes(FS_FORMAT);
 
-  var fs = this;
+  const fs = this;
   fs.readyState = FS_PENDING;
   fs.name = name;
   fs.error = null;
@@ -150,24 +155,24 @@ function FileSystem(options, callback) {
   fs.stderr = STDERR;
 
   // Expose Node's fs.constants to users
-  fs.constants = Constants.fsConstants;
+  fs.constants = fsConstants;
   // Node also forwards the access mode flags onto fs
-  fs.F_OK = Constants.fsConstants.F_OK;
-  fs.R_OK = Constants.fsConstants.R_OK;
-  fs.W_OK = Constants.fsConstants.W_OK;
-  fs.X_OK = Constants.fsConstants.X_OK;
+  fs.F_OK = fsConstants.F_OK;
+  fs.R_OK = fsConstants.R_OK;
+  fs.W_OK = fsConstants.W_OK;
+  fs.X_OK = fsConstants.X_OK;
 
   // Expose Shell constructor
   this.Shell = Shell.bind(undefined, this);
 
   // Safely expose the operation queue
-  var queue = [];
-  this.queueOrRun = function(operation) {
-    var error;
+  let queue = [];
+  this.queueOrRun = function (operation) {
+    let error;
 
-    if(FS_READY === fs.readyState) {
+    if (FS_READY === fs.readyState) {
       operation.call(fs);
-    } else if(FS_ERROR === fs.readyState) {
+    } else if (FS_ERROR === fs.readyState) {
       error = new Errors.EFILESYSTEMERROR('unknown error');
     } else {
       queue.push(operation);
@@ -176,25 +181,25 @@ function FileSystem(options, callback) {
     return error;
   };
   function runQueued() {
-    queue.forEach(function(operation) {
+    queue.forEach(function (operation) {
       operation.call(this);
     }.bind(fs));
     queue = null;
   }
 
   // We support the optional `options` arg from node, but ignore it
-  this.watch = function(filename, options, listener) {
-    if(Path.isNull(filename)) {
+  this.watch = function (filename, options, listener) {
+    if (Path.isNull(filename)) {
       throw new Error('Path must be a string without null bytes.');
     }
-    if(typeof options === 'function') {
+    if (typeof options === 'function') {
       listener = options;
       options = {};
     }
     options = options || {};
     listener = listener || nop;
 
-    var watcher = new FSWatcher();
+    const watcher = new FSWatcher();
     watcher.start(filename, false, options.recursive);
     watcher.on('change', listener);
 
@@ -203,24 +208,24 @@ function FileSystem(options, callback) {
 
   // Deal with various approaches to node ID creation
   function wrappedGuidFn(context) {
-    return function(callback) {
+    return function (callback) {
       // Skip the duplicate ID check if asked to
-      if(flags.includes(FS_NODUPEIDCHECK)) {
+      if (flags.includes(FS_NODUPEIDCHECK)) {
         callback(null, guid());
         return;
       }
 
       // Otherwise (default) make sure this id is unused first
       function guidWithCheck(callback) {
-        var id = guid();
-        context.getObject(id, function(err, value) {
-          if(err) {
+        const id = guid();
+        context.getObject(id, function (err, value) {
+          if (err) {
             callback(err);
             return;
           }
 
           // If this id is unused, use it, otherwise find another
-          if(!value) {
+          if (!value) {
             callback(null, id);
           } else {
             guidWithCheck(callback);
@@ -234,28 +239,28 @@ function FileSystem(options, callback) {
   // Let other instances (in this or other windows) know about
   // any changes to this fs instance.
   function broadcastChanges(changes) {
-    if(!changes.length) {
+    if (!changes.length) {
       return;
     }
-    var intercom = Intercom.getInstance();
-    changes.forEach(function(change) {
+    const intercom = Intercom.getInstance();
+    changes.forEach(function (change) {
       intercom.emit(change.event, change.path);
     });
   }
 
   // Open file system storage provider
-  provider.open(function(err) {
+  provider.open(function (err) {
     function complete(error) {
       function wrappedContext(methodName) {
-        var context = provider[methodName]();
+        let context = provider[methodName]();
         context.name = name;
         context.flags = flags;
         context.changes = [];
         context.guid = wrappedGuidFn(context);
 
         // When the context is finished, let the fs deal with any change events
-        context.close = function() {
-          var changes = context.changes;
+        context.close = function () {
+          let changes = context.changes;
           broadcastChanges(changes);
           changes.length = 0;
         };
@@ -268,15 +273,15 @@ function FileSystem(options, callback) {
       // for paths updated during the lifetime of the context). From this
       // point forward we won't call open again, so it's safe to drop it.
       fs.provider = {
-        openReadWriteContext: function() {
+        openReadWriteContext: function () {
           return wrappedContext('getReadWriteContext');
         },
-        openReadOnlyContext: function() {
+        openReadOnlyContext: function () {
           return wrappedContext('getReadOnlyContext');
         }
       };
 
-      if(error) {
+      if (error) {
         fs.readyState = FS_ERROR;
       } else {
         fs.readyState = FS_READY;
@@ -285,18 +290,18 @@ function FileSystem(options, callback) {
       callback(error, fs);
     }
 
-    if(err) {
+    if (err) {
       return complete(err);
     }
 
-    var context = provider.getReadWriteContext();
+    const context = provider.getReadWriteContext();
     context.guid = wrappedGuidFn(context);
 
     // Mount the filesystem, formatting if necessary
-    if(forceFormatting) {
+    if (forceFormatting) {
       // Wipe the storage provider, then write root block
-      context.clear(function(err) {
-        if(err) {
+      context.clear(function (err) {
+        if (err) {
           return complete(err);
         }
         impl.ensureRootDirectory(context, complete);
@@ -317,13 +322,13 @@ function FileSystem(options, callback) {
    * can be processed and validated before being passed on to the method.
    */
   [
-    { name: 'appendFile', promises: true, absPathArgs: [ 0 ] },
-    { name: 'access', promises: true, absPathArgs: [ 0 ] },
-    { name: 'chown', promises: true, absPathArgs: [ 0 ] },
-    { name: 'chmod', promises: true, absPathArgs: [ 0 ] },
+    { name: 'appendFile', promises: true, absPathArgs: [0] },
+    { name: 'access', promises: true, absPathArgs: [0] },
+    { name: 'chown', promises: true, absPathArgs: [0] },
+    { name: 'chmod', promises: true, absPathArgs: [0] },
     { name: 'close' },
     // copyFile - https://github.com/filerjs/filer/issues/436
-    { name: 'exists', absPathArgs: [ 0 ] },
+    { name: 'exists', absPathArgs: [0] },
     { name: 'fchown' },
     { name: 'fchmod' },
     // fdatasync - https://github.com/filerjs/filer/issues/653
@@ -334,64 +339,64 @@ function FileSystem(options, callback) {
     { name: 'fsync' },
     { name: 'ftruncate' },
     { name: 'futimes' },
-    { name: 'getxattr', promises: true, absPathArgs: [ 0 ] },
+    { name: 'getxattr', promises: true, absPathArgs: [0] },
     // lchown - https://github.com/filerjs/filer/issues/620
     // lchmod - https://github.com/filerjs/filer/issues/619
     { name: 'link', promises: true, absPathArgs: [0, 1] },
     { name: 'lseek' },
     { name: 'lstat', promises: true },
-    { name: 'mkdir', promises: true, absPathArgs: [ 0 ] },
+    { name: 'mkdir', promises: true, absPathArgs: [0] },
     { name: 'mkdtemp', promises: true },
-    { name: 'mknod', promises: true, absPathArgs: [ 0 ] },
-    { name: 'open', promises: true, absPathArgs: [ 0 ] },
-    { name: 'readdir', promises: true, absPathArgs: [ 0 ] },
+    { name: 'mknod', promises: true, absPathArgs: [0] },
+    { name: 'open', promises: true, absPathArgs: [0] },
+    { name: 'readdir', promises: true, absPathArgs: [0] },
     { name: 'read' },
-    { name: 'readFile', promises: true, absPathArgs: [ 0 ] },
-    { name: 'readlink', promises: true, absPathArgs: [ 0 ] },
+    { name: 'readFile', promises: true, absPathArgs: [0] },
+    { name: 'readlink', promises: true, absPathArgs: [0] },
     // realpath - https://github.com/filerjs/filer/issues/85
-    { name: 'removexattr', promises: true, absPathArgs: [ 0 ] },
+    { name: 'removexattr', promises: true, absPathArgs: [0] },
     { name: 'rename', promises: true, absPathArgs: [0, 1] },
-    { name: 'rmdir', promises: true, absPathArgs: [ 0 ] },
-    { name: 'setxattr', promises: true, absPathArgs: [ 0 ] },
-    { name: 'stat', promises: true, absPathArgs: [ 0 ] },
-    { name: 'symlink', promises: true, relPathArgs: [ 0 ], absPathArgs: [ 1 ] },
-    { name: 'truncate', promises: true, absPathArgs: [ 0 ] },
+    { name: 'rmdir', promises: true, absPathArgs: [0] },
+    { name: 'setxattr', promises: true, absPathArgs: [0] },
+    { name: 'stat', promises: true, absPathArgs: [0] },
+    { name: 'symlink', promises: true, relPathArgs: [0], absPathArgs: [1] },
+    { name: 'truncate', promises: true, absPathArgs: [0] },
     // unwatchFile - https://github.com/filerjs/filer/pull/553
-    { name: 'unlink', promises: true, absPathArgs: [ 0 ] },
-    { name: 'utimes', promises: true, absPathArgs: [ 0 ] },
+    { name: 'unlink', promises: true, absPathArgs: [0] },
+    { name: 'utimes', promises: true, absPathArgs: [0] },
     // watch - implemented above in `this.watch`
     // watchFile - https://github.com/filerjs/filer/issues/654
-    { name: 'writeFile', promises: true, absPathArgs: [ 0 ] },
+    { name: 'writeFile', promises: true, absPathArgs: [0] },
     { name: 'write' }
-  ].forEach(function(method) {
-    var methodName = method.name;
-    var shouldPromisify = method.promises === true;
+  ].forEach(function (method) {
+    const methodName = method.name;
+    const shouldPromisify = method.promises === true;
 
-    FileSystem.prototype[methodName] = function() {
-      var fs = this;
-      var args = Array.prototype.slice.call(arguments, 0);
-      var lastArgIndex = args.length - 1;
+    FileSystem.prototype[methodName] = function () {
+      const fs = this;
+      const args = Array.prototype.slice.call(arguments, 0);
+      const lastArgIndex = args.length - 1;
 
       // We may or may not get a callback, and since node.js supports
       // fire-and-forget style fs operations, we have to dance a bit here.
-      var missingCallback = typeof args[lastArgIndex] !== 'function';
-      var callback = maybeCallback(args[lastArgIndex]);
+      const missingCallback = typeof args[lastArgIndex] !== 'function';
+      const callback = maybeCallback(args[lastArgIndex]);
 
       // Deal with path arguments, validating and normalizing Buffer and file:// URLs
-      if(method.absPathArgs) {
+      if (method.absPathArgs) {
         method.absPathArgs.forEach(pathArg => processPathArg(args, pathArg, false));
       }
-      if(method.relPathArgs) {
+      if (method.relPathArgs) {
         method.relPathArgs.forEach(pathArg => processPathArg(args, pathArg, true));
       }
 
-      var error = fs.queueOrRun(function() {
-        var context = fs.provider.openReadWriteContext();
+      const error = fs.queueOrRun(function () {
+        const context = fs.provider.openReadWriteContext();
 
         // Fail early if the filesystem is in an error state (e.g.,
         // provider failed to open.
-        if(FS_ERROR === fs.readyState) {
-          var err = new Errors.EFILESYSTEMERROR('filesystem unavailable, operation canceled');
+        if (FS_ERROR === fs.readyState) {
+          const err = new Errors.EFILESYSTEMERROR('filesystem unavailable, operation canceled');
           return callback.call(fs, err);
         }
 
@@ -402,7 +407,7 @@ function FileSystem(options, callback) {
         }
 
         // Either add or replace the callback with our wrapper complete()
-        if(missingCallback) {
+        if (missingCallback) {
           args.push(complete);
         } else {
           args[lastArgIndex] = complete;
@@ -411,16 +416,16 @@ function FileSystem(options, callback) {
         // Forward this call to the impl's version, using the following
         // call signature, with complete() as the callback/last-arg now:
         // fn(fs, context, arg0, arg1, ... , complete);
-        var fnArgs = [context].concat(args);
+        const fnArgs = [context].concat(args);
         impl[methodName].apply(null, fnArgs);
       });
-      if(error) {
+      if (error) {
         callback(error);
       }
     };
-    
+
     // Add to fs.promises if appropriate
-    if(shouldPromisify) {
+    if (shouldPromisify) {
       FileSystem.prototype.promises[methodName] = promisify(FileSystem.prototype[methodName].bind(fs));
     }
   });

src/fs-watcher.js

@@ -1,6 +1,8 @@
-var EventEmitter = require('../lib/eventemitter.js');
-var Path = require('./path.js');
-var Intercom = require('../lib/intercom.js');
+'using strict';
+
+const EventEmitter = require('../lib/eventemitter.js');
+const Path = require('./path.js');
+const Intercom = require('../lib/intercom.js');
 
 /**
  * FSWatcher based on node.js' FSWatcher
@@ -8,10 +10,10 @@ var Intercom = require('../lib/intercom.js');
  */
 function FSWatcher() {
   EventEmitter.call(this);
-  var self = this;
-  var recursive = false;
-  var recursivePathPrefix;
-  var filename;
+  const self = this;
+  let recursive = false;
+  let recursivePathPrefix;
+  let filename;
 
   function onchange(path) {
     // Watch for exact filename, or parent path when recursive is true.
@@ -46,12 +48,12 @@ function FSWatcher() {
       recursivePathPrefix = filename === '/' ? '/' : filename + '/';
     }
 
-    var intercom = Intercom.getInstance();
+    const intercom = Intercom.getInstance();
     intercom.on('change', onchange);
   };
 
   self.close = function() {
-    var intercom = Intercom.getInstance();
+    const intercom = Intercom.getInstance();
     intercom.off('change', onchange);
     self.removeAllListeners('change');
   };

src/index.js

@@ -8,7 +8,17 @@ module.exports = Filer = {
   Path: require('./path.js'),
   path: require('./path.js'),
   Errors: require('./errors.js'),
-  Shell: require('./shell/shell.js')
+  Shell: require('./shell/shell.js'),
+  /**
+   * @deprecated Importing filer from your webpack config is not recommended.
+   * 
+   * The filer `FilerWebpackPlugin` class is exposed directly. 
+   * 
+   * ```
+   * const { FilerWebpackPlugin } = require('filer/webpack');
+   * ```
+   */
+  FilerWebpackPlugin: require('./webpack-plugin'),
 };
 
 // Add a getter for the `fs` instance, which returns

src/path.js

@@ -10,7 +10,7 @@ process.cwd = () => '/';
  * a few things we need for the browser environment.
  */
 const nodePath = require('path');
-const filerPath = Object.create(nodePath);
+const filerPath = Object.assign({}, nodePath);
 
 /**
  * Patch path.basename() to return / vs. ''

src/providers/indexeddb.js

@@ -3,11 +3,6 @@ var FILE_STORE_NAME = require('../constants.js').FILE_STORE_NAME;
 var IDB_RW = require('../constants.js').IDB_RW;
 var IDB_RO = require('../constants.js').IDB_RO;
 
-var indexedDB = global.indexedDB       ||
-                global.mozIndexedDB    ||
-                global.webkitIndexedDB ||
-                global.msIndexedDB;
-
 function IndexedDBContext(db, mode) {
   this.db = db;
   this.mode = mode;
@@ -114,6 +109,10 @@ function IndexedDB(name) {
   this.db = null;
 }
 IndexedDB.isSupported = function() {
+  var indexedDB = global.indexedDB       ||
+                  global.mozIndexedDB    ||
+                  global.webkitIndexedDB ||
+                  global.msIndexedDB;
   return !!indexedDB;
 };
 
@@ -126,6 +125,11 @@ IndexedDB.prototype.open = function(callback) {
   }
 
   try {
+    var indexedDB = global.indexedDB       ||
+                    global.mozIndexedDB    ||
+                    global.webkitIndexedDB ||
+                    global.msIndexedDB;
+
     // NOTE: we're not using versioned databases.
     var openRequest = indexedDB.open(that.name);
 

src/providers/memory.js

@@ -9,7 +9,7 @@ var asyncCallback = require('../../lib/async.js').setImmediate;
 var createDB = (function() {
   var pool = {};
   return function getOrCreate(name) {
-    if(!pool.hasOwnProperty(name)) {
+    if(!Object.prototype.hasOwnProperty.call(pool, name)) {
       pool[name] = {};
     }
     return pool[name];

src/shell/environment.js

@@ -1,4 +1,5 @@
-var defaults = require('../constants.js').ENVIRONMENT;
+'use strict'; 
+const defaults = require('../constants.js').ENVIRONMENT;
 
 module.exports = function Environment(env) {
   env = env || {};

src/shell/shell.js

@@ -387,7 +387,8 @@ Shell.prototype.mkdirp = function(path, callback) {
     callback(new Errors.EINVAL('Missing path argument'));
     return;
   }
-  else if (path === '/') {
+  path = Path.resolve(sh.pwd(), path);
+  if (path === '/') {
     callback();
     return;
   }

src/stats.js

@@ -1,9 +1,10 @@
-var Constants = require('./constants.js');
-var Path = require('./path.js');
+'use strict';
 
-// https://github.com/nodejs/node/blob/4f1297f259b09d129ac01afbd4c674263b7ac124/lib/internal/fs/utils.js#L231
-function dateFromNumeric(num) {
-  return new Date(Number(num) * 1000);
+const Constants = require('./constants.js');
+const Path = require('./path.js');
+
+function dateFromMs(ms) {
+  return new Date(Number(ms));
 }
 
 function Stats(path, fileNode, devName) {
@@ -13,10 +14,10 @@ function Stats(path, fileNode, devName) {
   this.size = fileNode.size;
   this.nlinks = fileNode.nlinks;
   // Date objects
-  this.atime = dateFromNumeric(fileNode.atime);
-  this.mtime = dateFromNumeric(fileNode.mtime);
-  this.ctime = dateFromNumeric(fileNode.ctime);
-  // Unix timestamp Numbers
+  this.atime = dateFromMs(fileNode.atime);
+  this.mtime = dateFromMs(fileNode.mtime);
+  this.ctime = dateFromMs(fileNode.ctime);
+  // Unix timestamp MS Numbers
   this.atimeMs = fileNode.atime;
   this.mtimeMs = fileNode.mtime;
   this.ctimeMs = fileNode.ctime;

src/webpack-plugin/index.js

@@ -0,0 +1,81 @@
+var path = require('path');
+var utils = require('./utils');
+
+const PLUGIN_NAME = 'filer-webpack-plugin';
+
+const OPTIONS_SCHEMA = require('./schema');
+const OPTIONS_PROCESSORS = require('./processors');
+
+module.exports = class FilerWebpackPlugin {
+
+  constructor(options = {}) {
+    utils.validateOptions(options, OPTIONS_SCHEMA);
+    this.options = utils.processOptions(options, OPTIONS_PROCESSORS);
+  }
+
+  apply(compiler) {
+    compiler.hooks.normalModuleFactory.tap(
+      PLUGIN_NAME,
+      (factory) => {
+        factory.hooks.resolve.tap(
+          PLUGIN_NAME,
+          (resolveData) => {
+            // Resolve fsProvider if required
+            if (
+              resolveData.request === 'fsProvider'
+              && resolveData.context === this.options.shimsDir
+            ) {
+              return this.resolveFsProvider(resolveData);
+            }
+
+            // Ignore filer files (these should resolve modules normally)
+            if (resolveData.context.startsWith(this.options.filerDir)) return;
+
+            // Apply fs, path and buffer shims if required
+            switch (resolveData.request) {
+            case 'fs':
+              if (!this.options.shimFs) return;
+              return this.applyFsShim(resolveData);
+            case 'path':
+              if (!this.options.shimPath) return;
+              return this.applyPathShim(resolveData);
+            default:
+              return;
+            }
+          }
+        );
+      },
+    );
+  }
+
+  resolveFsProvider(resolveData) {
+    switch (this.options.fsProvider) {
+    case 'default':
+      resolveData.request = path.join(this.options.fsProviderDir, 'default.js');
+      break;
+    case 'indexeddb':
+      resolveData.request = path.join(this.options.fsProviderDir, 'indexeddb.js');
+      break;
+    case 'memory':
+      resolveData.request = path.join(this.options.fsProviderDir, 'memory.js');
+      break;
+    case 'custom':
+      resolveData.request = path.join(this.options.fsProviderDir, 'custom.js');
+      break;
+    default:
+      throw new Error([
+        'Invalid option for fsProvider.',
+        'fsProvider must be one of \'default\', \'indexeddb\', \'memory\' or \'custom\'.',
+        'If using a custom fsProvider, you must also provide the fsProviderDir option.'
+      ].join(' '));
+    }
+  }
+
+  applyFsShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'fs.js');
+  }
+    
+  applyPathShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'path.js');
+  }
+};

src/webpack-plugin/processors.js

@@ -0,0 +1,34 @@
+var path = require('path');
+
+const ROOT_DIR_TAG = '<rootDir>';
+const CWD = process.cwd();
+
+module.exports = {
+  filerDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimsDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    }
+  },
+  fsProviderDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims', 'providers');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimFs: { default: true },
+  shimPath: { default: true},
+  fsProvider: { default: 'default'},
+};

src/webpack-plugin/schema.js

@@ -0,0 +1,23 @@
+module.exports = {
+  type: 'object',
+  properties: {
+    filerDir: {
+      type: 'string',
+    },
+    shimsDir: {
+      type: 'string',
+    },
+    shimFs: {
+      type: 'boolean',
+    },
+    shimPath: {
+      type: 'boolean',
+    },
+    fsProvider: {
+      type: 'string',
+    },
+    fsProviderDir: {
+      type: 'string',
+    },
+  }
+};

src/webpack-plugin/utils.js

@@ -0,0 +1,26 @@
+var { validate } = require('schema-utils');
+
+function validateOptions(options, schema) {
+  validate(schema, options);
+}
+
+function processOptions(options, processors) {
+  const processedOptions = {};
+    
+  for (const [property, processor] of Object.entries(processors)) {
+    processedOptions[property] = options[property];
+    if (processedOptions[property] === undefined) {
+      processedOptions[property] = processor.default;
+    }
+    if (processor.process) {
+      processedOptions[property] = processor.process(processedOptions[property]);
+    }
+  }
+
+  return processedOptions;
+}
+
+module.exports = {
+  validateOptions,
+  processOptions,
+};

tests/bugs/issue773.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('unexpected failures when calling fs functions (e.g. writeFile) with empty options object, issue 773', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it('should call fs.writeFile with an empty options object', function(done) {
+    const fs = util.fs();
+    fs.writeFile('/a', 'trololol', {}, done);
+  });
+});

tests/bugs/issue775.js

@@ -0,0 +1,115 @@
+'use strict';
+var util = require('../lib/test-utils.js');
+var expect = require('chai').expect;
+
+describe('fs.readdir fails when passing options, issue775', function () {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  function setup(fs, dir, cb) {
+    fs.mkdir(dir, undefined, (err) => {
+      if (err) {
+        cb(err);
+      }
+      else {
+        fs.writeFile(dir + '/file', '', (err) => {
+          if (err) {
+            cb(err);
+          }
+          else {
+            fs.mkdir(dir + '/folder', (err) => {
+              if (err) {
+                cb(err);
+              }
+              else {
+                fs.symlink(dir + '/file', dir + '/symlink', (err) => {
+                  if (err) {
+                    cb(err);
+                  }
+                  else {
+                    cb();
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with buffer encoding', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', 'buffer', (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(data[0].toString()).to.equal('file');
+          expect(data[1].toString()).to.equal('folder');
+          expect(data[2].toString()).to.equal('symlink');
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with withFileTypes and encoding options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', { encoding: 'base64', withFileTypes: true }, (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(Buffer.from(data[0].name, 'base64').toString()).to.equal('file');
+          expect(Buffer.from(data[1].name, 'base64').toString()).to.equal('folder');
+          expect(Buffer.from(data[2].name, 'base64').toString()).to.equal('symlink');
+
+          expect(data[0].isFile()).to.be.true;
+          expect(data[1].isDirectory()).to.be.true;
+          expect(data[2].isSymbolicLink()).to.be.true;
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory then call fs.readdir without options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      else {
+        fs.readdir('/test_dir', (err, data) => {
+          if (err) {
+            done(err);
+          }
+          else {
+            expect(data).to.have.length(3);
+
+            expect(data[0]).to.equal('file');
+            expect(data[1]).to.equal('folder');
+            expect(data[2]).to.equal('symlink');
+
+            done();
+          }
+        });
+      }
+    });
+  });
+});

tests/bugs/issue776.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('fs.mkdir does not recursively create parent directories when called with { recursive: true }, issue776', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it.skip('should not throw when calling fs.mkdir with recursive flag set', function(done) {
+    const fs = util.fs();
+    fs.mkdir('/test_dir/a/b', { recursive: true }, done);
+  });
+});

tests/index.html

@@ -12,7 +12,7 @@
   <script src="../node_modules/mocha/mocha.js"></script>
 
   <script>
-    mocha.setup('bdd').timeout(5000).slow(250);
+    mocha.setup('bdd').timeout(10000).slow(250);
 
     window.onload = function() {
       mocha.checkLeaks();

tests/index.js

@@ -3,6 +3,13 @@
  * get them running by default.
  */
 
+// Shims
+require('./spec/shims/fs.spec');
+require('./spec/shims/path.spec');
+
+// Webpack Plugin
+require('./spec/webpack-plugin/webpack-plugin.spec');
+
 // Filer
 require('./spec/filer.spec');
 require('./spec/filer.buffer.spec.js');
@@ -36,7 +43,6 @@ require('./spec/fs.truncate.spec');
 require('./spec/fs.ftruncate.spec');
 require('./spec/fs.utimes.spec');
 require('./spec/fs.xattr.spec');
-require('./spec/fs.stats.spec');
 require('./spec/path-resolution.spec');
 require('./spec/trailing-slashes.spec');
 require('./spec/times.spec');
@@ -85,6 +91,9 @@ require('./bugs/issue267.js');
 require('./bugs/issue270.js');
 require('./bugs/rename-dir-trailing-slash.js');
 require('./bugs/issue357.js');
+require('./bugs/issue773.js');
+require('./bugs/issue775.js');
+require('./bugs/issue776.js');
 
 // Sample code from README
 require('./spec/readme.example.spec');

tests/lib/indexeddb.js

@@ -1,11 +1,8 @@
-var Filer = require('../../src');
+'use strict';
 
-var indexedDB = global.indexedDB       ||
-                global.mozIndexedDB    ||
-                global.webkitIndexedDB ||
-                global.msIndexedDB;
+const Filer = require('../../src');
 
-var needsCleanup = [];
+let needsCleanup = [];
 if(global.addEventListener) {
   global.addEventListener('beforeunload', function() {
     needsCleanup.forEach(function(f) { f(); });
@@ -13,8 +10,8 @@ if(global.addEventListener) {
 }
 
 function IndexedDBTestProvider(name) {
-  var _done = false;
-  var that = this;
+  let _done = false;
+  let that = this;
 
   function cleanup(callback) {
     callback = callback || function(){};
@@ -36,7 +33,12 @@ function IndexedDBTestProvider(name) {
         that.provider.db.close();
       }
 
-      var request = indexedDB.deleteDatabase(name);
+      const indexedDB = global.indexedDB       ||
+                      global.mozIndexedDB    ||
+                      global.webkitIndexedDB ||
+                      global.msIndexedDB;
+
+      let request = indexedDB.deleteDatabase(name);
       request.onsuccess = finished;
       request.onerror = finished;
     } catch(e) {

tests/lib/test-utils.js

@@ -43,6 +43,24 @@ function getProviderType() {
   return queryString['filer-provider'] || defaultProvider;
 }
 
+// Run fn() in an environment with indexedDB available
+// either as-is, or shimmed, removing when done.
+function shimIndexedDB(fn) {
+  var addShim = !Filer.FileSystem.providers.IndexedDB.isSupported();
+
+  if(addShim) {
+    global.indexedDB = require('fake-indexeddb');
+  }
+
+  var result = fn();
+
+  if(addShim) {
+    delete global.indexedDB;
+  }
+
+  return result;
+}
+
 function setup(callback) {
   // In browser we support specifying the provider via the query string
   // (e.g., ?filer-provider=IndexedDB). If not specified, we use
@@ -141,6 +159,24 @@ const parseBJSON = json =>
       value
   );
 
+function createMockFn(implementation = undefined) {
+  const calls = [];
+  const mockFn = function(...args) {
+    calls.push({
+      args,
+    });
+    if (typeof implementation === 'function') {
+      return implementation(...args);
+    }
+  };
+  Object.defineProperty(mockFn, 'calls', {
+    get() {
+      return calls;
+    }
+  });
+  return mockFn;
+}
+
 module.exports = {
   uniqueName: uniqueName,
   setup: setup,
@@ -153,5 +189,7 @@ module.exports = {
   },
   cleanup: cleanup,
   typedArrayEqual: typedArrayEqual,
-  parseBJSON
+  parseBJSON,
+  shimIndexedDB,
+  createMockFn
 };

tests/spec/errors.spec.js

@@ -1,5 +1,7 @@
-var Filer = require('../../src');
-var expect = require('chai').expect;
+'use strict';
+
+const Filer = require('../../src');
+const expect = require('chai').expect;
 
 describe('Filer.Errors', function() {
   it('has expected errors', function() {
@@ -135,7 +137,7 @@ describe('Filer.Errors', function() {
   });
 
   it('should include all expected properties by default', function() {
-    var err = new Filer.Errors.ENOENT();
+    const err = new Filer.Errors.ENOENT();
     expect(err.name).to.equal('ENOENT');
     expect(err.code).to.equal('ENOENT');
     expect(err.errno).to.equal(34);
@@ -143,7 +145,7 @@ describe('Filer.Errors', function() {
   });
 
   it('should include extra properties when provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
     expect(err.name).to.equal('ENOENT');
     expect(err.code).to.equal('ENOENT');
     expect(err.errno).to.equal(34);
@@ -152,29 +154,29 @@ describe('Filer.Errors', function() {
   });
 
   it('should include default message and path info when provided', function() {
-    var err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
     expect(err.message).to.equal('no such file or directory');
     expect(err.path).to.equal('/this/is/the/path');
   });
 
   it('should include just the message when no path provided', function() {
-    var err = new Filer.Errors.ENOENT();
+    const err = new Filer.Errors.ENOENT();
     expect(err.message).to.equal('no such file or directory');
     expect(err.path).not.to.exist;
   });
 
   it('should not include path in toString() when not provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message');
+    const err = new Filer.Errors.ENOENT('This is the message');
     expect(err.toString()).to.equal('ENOENT: This is the message');
   });
 
   it('should include path in toString() when provided', function() {
-    var err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
     expect(err.toString()).to.equal('ENOENT: no such file or directory, \'/this/is/the/path\'');
   });
 
   it('should include message and path info when provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
     expect(err.message).to.equal('This is the message');
     expect(err.path).to.equal('/this/is/the/path');
   });

tests/spec/filer.buffer.spec.js

@@ -1,5 +1,7 @@
-var Filer = require('../../src');
-var expect = require('chai').expect;
+'use strict';
+
+const Filer = require('../../src');
+const expect = require('chai').expect;
 
 describe('Filer.Buffer', function() {
 
@@ -12,37 +14,37 @@ describe('Filer.Buffer', function() {
   });
 
   it('should support .isBuffer()', function() {
-    var buf = Buffer.alloc(0);
+    const buf = Buffer.alloc(0);
     expect(Buffer.isBuffer(buf)).to.be.true;
   });
 
   describe('Deprecation checks - constructor vs. class method init', function() {
 
     it('should allow new Buffer(array)', function() {
-      var arr = [1, 2, 3];
-      var buf1 = new Buffer(arr);
-      var buf2 = new Buffer.from(arr);
+      const arr = [1, 2, 3];
+      const buf1 = new Buffer(arr);
+      const buf2 = new Buffer.from(arr);
       expect(buf1).to.deep.equal(buf2);
     });
 
     it('should allow new Buffer(ArrayBuffer)', function() {
-      var arrayBuffer = (new Uint8Array([1, 2, 3])).buffer;
-      var buf1 = new Buffer(arrayBuffer);
-      var buf2 = Buffer.from(arrayBuffer);
+      const arrayBuffer = (new Uint8Array([1, 2, 3])).buffer;
+      const buf1 = new Buffer(arrayBuffer);
+      const buf2 = Buffer.from(arrayBuffer);
       expect(buf1).to.deep.equal(buf2);
     });
 
     it('should allow new Buffer(ArrayBuffer)', function() {
-      var buffer = new Buffer.from([1, 2, 3]);
-      var buf1 = new Buffer(buffer);
-      var buf2 = Buffer.from(buffer);
+      const buffer = new Buffer.from([1, 2, 3]);
+      const buf1 = new Buffer(buffer);
+      const buf2 = Buffer.from(buffer);
       expect(buf1).to.deep.equal(buf2);
     });
 
     it('should allow new Buffer(string)', function() {
-      var s = 'Hello World';
-      var buf1 = new Buffer(s);
-      var buf2 = Buffer.from(s);
+      const s = 'Hello World';
+      const buf1 = new Buffer(s);
+      const buf2 = Buffer.from(s);
       expect(buf1).to.deep.equal(buf2);
     });
   });

tests/spec/filer.filesystem.spec.js

@@ -1,16 +1,17 @@
-var Filer = require('../../src');
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const Filer = require('../../src');
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('Filer.FileSystem', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should properly mount new or existing filesystem', function(done) {
-    var provider = util.provider().provider;
+    const provider = util.provider().provider;
 
     // 1) Should be able to open a new filesystem, and get empty root
-    var fs1 = new Filer.FileSystem({provider: provider}, function() {
+    const fs1 = new Filer.FileSystem({provider: provider}, function() {
       fs1.readdir('/', function(err, entries) {
         expect(err).not.to.exist;
         expect(entries).to.be.an('array');
@@ -20,7 +21,7 @@ describe('Filer.FileSystem', function() {
           if(err) throw err;
 
           // 2) Should be able to open an existing filesystem
-          var fs2 = new Filer.FileSystem({provider: provider}, function() {
+          const fs2 = new Filer.FileSystem({provider: provider}, function() {
             fs2.readdir('/', function(err, entries) {
               expect(err).not.to.exist;
               expect(entries).to.be.an('array');
@@ -29,7 +30,7 @@ describe('Filer.FileSystem', function() {
 
 
               // 3) FORMAT flag should wipe an existing filesystem
-              var fs3 = new Filer.FileSystem({provider: provider, flags: ['FORMAT']}, function() {
+              const fs3 = new Filer.FileSystem({provider: provider, flags: ['FORMAT']}, function() {
                 fs3.readdir('/', function(err, entries) {
                   expect(err).not.to.exist;
                   expect(entries).to.be.an('array');

tests/spec/filer.spec.js

@@ -1,5 +1,7 @@
-var Filer = require('../../src');
-var expect = require('chai').expect;
+'use strict';
+const Filer = require('../../src');
+const util = require('../lib/test-utils');
+const expect = require('chai').expect;
 
 describe('Filer', function() {
   it('is defined', function() {
@@ -26,19 +28,17 @@ describe('Filer', function() {
 
   it('has an fs object that returns a Filer.FileSystem', function() {
     // Depends on IndexedDB being available, since we can't
-    // configure our own test provider.
-    if(!Filer.FileSystem.providers.IndexedDB.isSupported()) {
-      this.skip();
-    }
+    // configure our own test provider.  Shim for coverage.
+    util.shimIndexedDB(function() {
+      expect(typeof Filer.fs).to.equal('object');
 
-    expect(typeof Filer.fs).to.equal('object');
-
-    const fs1 = Filer.fs;
-    const fs2 = Filer.fs;
-
-    expect(fs1).to.be.an.instanceof(Filer.FileSystem);
-    expect(fs2).to.be.an.instanceof(Filer.FileSystem);
-    expect(fs1).to.equal(fs2);
+      const fs1 = Filer.fs;
+      const fs2 = Filer.fs;
+  
+      expect(fs1).to.be.an.instanceof(Filer.FileSystem);
+      expect(fs2).to.be.an.instanceof(Filer.FileSystem);
+      expect(fs1).to.equal(fs2);  
+    });
   });
 
   it('has Shell constructor', function() {
@@ -46,21 +46,21 @@ describe('Filer', function() {
   });
 
   it('must honor the \'FORMAT\' flag', function(done) {
-    var name = 'local-test';
+    const name = 'local-test';
     // Because we need to use a bunch of Filer filesystems
     // in this test, we can't use the usual test infrastructure
     // to create/manage the fs instance.  Pick the best one
     // based on the testing environment (browser vs. node)
-    var providers = Filer.FileSystem.providers;
-    var Provider;
+    const providers = Filer.FileSystem.providers;
+    let Provider;
     if(providers.IndexedDB.isSupported()) {
       Provider = providers.IndexedDB;
     } else {
       Provider = providers.Memory;
     }
 
-    var fs = new Filer.FileSystem({name, provider: new Provider(name)});
-    var fs2 = new Filer.FileSystem({name, provider: new Provider(name)});
+    let fs = new Filer.FileSystem({name, provider: new Provider(name)});
+    let fs2 = new Filer.FileSystem({name, provider: new Provider(name)});
 
     fs.mkdir('/test', function(err){
       if(err) throw err;

tests/spec/fs.access.spec.js

@@ -1,12 +1,14 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.access', function () {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should expose access mode flags on fs and fs.constants', function() {
-    var fs = util.fs();
+    const fs = util.fs();
 
     // F_OK
     expect(fs.F_OK).to.equal(0);
@@ -26,12 +28,12 @@ describe('fs.access', function () {
   });
 
   it('should be a function', function () {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.access).to.equal('function');
   });
 
   it('should return an error if file does not exist', function (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.access('/tmp', fs.constants.F_OK, function (error) {
       expect(error).to.exist;
@@ -41,8 +43,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and mode = F_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -55,8 +57,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and mode = R_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -69,8 +71,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and mode = W_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
    
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -83,8 +85,8 @@ describe('fs.access', function () {
   });
 
   it('should return an error if file is not executable and mode = X_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
    
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -102,8 +104,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and mode = X_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
    
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -120,8 +122,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and no mode is passed', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;
@@ -134,8 +136,8 @@ describe('fs.access', function () {
   });
 
   it('should return no error if file does exist and mode = R_OK | W_OK', function (done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
    
     fs.writeFile('/myfile', contents, function (error) {
       if (error) throw error;

tests/spec/fs.appendFile.spec.js

@@ -1,12 +1,14 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.appendFile', function() {
   const contents = 'This is a file.';
 
   beforeEach(function(done) {
     util.setup(function() {
-      var fs = util.fs();
+      const fs = util.fs();
       fs.writeFile('/myfile', contents, function(error) {
         if(error) throw error;
         done();
@@ -16,13 +18,13 @@ describe('fs.appendFile', function() {
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.appendFile).to.be.a('function');
   });
 
   it('should append a utf8 file without specifying utf8 in appendFile', function(done) {
-    var fs = util.fs();
-    var more = ' Appended.';
+    const fs = util.fs();
+    const more = ' Appended.';
 
     fs.appendFile('/myfile', more, function(error) {
       if(error) throw error;
@@ -36,8 +38,8 @@ describe('fs.appendFile', function() {
   });
 
   it('should append a utf8 file with "utf8" option to appendFile', function(done) {
-    var fs = util.fs();
-    var more = ' Appended.';
+    const fs = util.fs();
+    const more = ' Appended.';
 
     fs.appendFile('/myfile', more, 'utf8', function(error) {
       if(error) throw error;
@@ -51,8 +53,8 @@ describe('fs.appendFile', function() {
   });
 
   it('should append a utf8 file with {encoding: "utf8"} option to appendFile', function(done) {
-    var fs = util.fs();
-    var more = ' Appended.';
+    const fs = util.fs();
+    const more = ' Appended.';
 
     fs.appendFile('/myfile', more, { encoding: 'utf8' }, function(error) {
       if(error) throw error;
@@ -66,12 +68,12 @@ describe('fs.appendFile', function() {
   });
 
   it('should append a binary file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     // String and utf8 binary encoded versions of the same thing: 'This is a file.'
-    var binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
-    var binary2 = Buffer.from([32, 65, 112, 112, 101, 110, 100, 101, 100, 46]);
-    var binary3 = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46,
+    const binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
+    const binary2 = Buffer.from([32, 65, 112, 112, 101, 110, 100, 101, 100, 46]);
+    const binary3 = Buffer.from([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]);
 
     fs.writeFile('/mybinaryfile', binary, function(error) {
@@ -90,9 +92,9 @@ describe('fs.appendFile', function() {
   });
 
   it('should follow symbolic links', function(done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
-    var more = ' Appended.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
+    const more = ' Appended.';
 
     fs.symlink('/myfile', '/myFileLink', function (error) {
       if (error) throw error;
@@ -110,7 +112,7 @@ describe('fs.appendFile', function() {
   });
 
   it('should work when file does not exist, and create the file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.appendFile('/newfile', contents, { encoding: 'utf8' }, function(error) {
       expect(error).not.to.exist;
@@ -124,8 +126,8 @@ describe('fs.appendFile', function() {
   });
   
   it('should accept numbers and append them to the file', function(done) {
-    var fs = util.fs();
-    var more = 10000;
+    const fs = util.fs();
+    const more = 10000;
 
     fs.appendFile('/myfile', more, 'utf8', function(error) {
       if(error) throw error;
@@ -142,7 +144,7 @@ describe('fs.appendFile', function() {
 describe('fs.promises.appendFile', function() {
   beforeEach(function(done) {
     util.setup(function() {
-      var fs = util.fs();
+      const fs = util.fs();
       return fs.promises.writeFile('/myfile', 'This is a file.', { encoding: 'utf8' })
         .then(done)
         .catch(done);
@@ -151,14 +153,14 @@ describe('fs.promises.appendFile', function() {
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.promises.appendFile).to.be.a('function');
   });
 
   it('should append a utf8 file without specifying utf8 in appendFile', function() {
-    var fs = util.fs();
-    var contents = 'This is a file.';
-    var more = ' Appended.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
+    const more = ' Appended.';
 
     return fs.promises.appendFile('/myfile', more)
       .then(() => fs.promises.readFile('/myfile', 'utf8'))
@@ -166,9 +168,9 @@ describe('fs.promises.appendFile', function() {
   });
 
   it('should append a utf8 file with "utf8" option to appendFile', function() {
-    var fs = util.fs();
-    var contents = 'This is a file.';
-    var more = ' Appended.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
+    const more = ' Appended.';
 
     return fs.promises.appendFile('/myfile', more, 'utf8')
       .then(() => fs.promises.readFile('/myfile', 'utf8'))
@@ -176,9 +178,9 @@ describe('fs.promises.appendFile', function() {
   });
 
   it('should append a utf8 file with {encoding: "utf8"} option to appendFile', function() {
-    var fs = util.fs();
-    var contents = 'This is a file.';
-    var more = ' Appended.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
+    const more = ' Appended.';
 
     return fs.promises.appendFile('/myfile', more, { encoding: 'utf8' })
       .then(() => fs.promises.readFile('/myfile', { encoding: 'utf8' }))
@@ -186,12 +188,12 @@ describe('fs.promises.appendFile', function() {
   });
 
   it('should append a binary file', function() {
-    var fs = util.fs();
+    const fs = util.fs();
 
     // String and utf8 binary encoded versions of the same thing: 'This is a file.'
-    var binary = new Buffer([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
-    var binary2 = new Buffer([32, 65, 112, 112, 101, 110, 100, 101, 100, 46]);
-    var binary3 = new Buffer([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46,
+    const binary = new Buffer([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
+    const binary2 = new Buffer([32, 65, 112, 112, 101, 110, 100, 101, 100, 46]);
+    const binary3 = new Buffer([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]);
 
     return fs.promises.writeFile('/mybinaryfile', binary)
@@ -201,9 +203,9 @@ describe('fs.promises.appendFile', function() {
   });
 
   it('should follow symbolic links', function() {
-    var fs = util.fs();
-    var contents = 'This is a file.';
-    var more = ' Appended.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
+    const more = ' Appended.';
 
     return fs.promises.symlink('/myfile', '/myFileLink')
       .then(() => fs.promises.appendFile('/myFileLink', more, 'utf8'))
@@ -212,8 +214,8 @@ describe('fs.promises.appendFile', function() {
   });
 
   it('should work when file does not exist, and create the file', function() {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     return fs.promises.appendFile('/newfile', contents, { encoding: 'utf8' })
       .then(() => fs.promises.readFile('/newfile', 'utf8'))

tests/spec/fs.chmod.spec.js

@@ -1,18 +1,20 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.chmod, fs.fchmod', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be functions', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.chmod).to.equal('function');
     expect(typeof fs.fchmod).to.equal('function');
   });
 
   it('should automatically set mode=755 for a directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -26,7 +28,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should automatically set mode=644 for a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/file', 'w', function(err, fd) {
       if(err) throw err;
@@ -40,7 +42,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should be an error when the path is invalid', function(done){
-    var fs = util.fs();
+    const fs = util.fs();
     fs.chmod('/invalid_path', 0o444, function(err){
       expect(err).to.exist;
       expect(err.code).to.equal('ENOENT');
@@ -49,7 +51,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should error if mode value is a non-numeric string', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -63,7 +65,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should error if mode value is null', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -77,7 +79,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should error if mode value is non-integer number', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -91,7 +93,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should error if mode value is non-integer number', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -105,7 +107,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should allow octal strings for mode value', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/dir', function(err) {
       if(err) throw err;
@@ -124,7 +126,7 @@ describe('fs.chmod, fs.fchmod', function() {
   });
 
   it('should allow for updating mode of a given file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/file', 'w', function(err, fd) {
       if(err) throw err;
@@ -161,12 +163,12 @@ describe('fsPromise.chmod', function() {
   afterEach(util.setup);
 
   it('should be a function', function() {
-    var fsPromise = util.fs().promises;
+    const fsPromise = util.fs().promises;
     expect(typeof fsPromise.chmod).to.equal('function');
   });
 
   it('should allow for updating mode of a given file', function() {
-    var fsPromise = util.fs().promises;
+    const fsPromise = util.fs().promises;
 
     return fsPromise.open('/file', 'w')
       .then(() => fsPromise.chmod('/file', 0o444))

tests/spec/fs.close.spec.js

@@ -1,23 +1,25 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict'; 
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.close', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.close).to.equal('function');
   });
 
   it('should release the file descriptor', function(done) {
-    var buffer = Buffer.alloc(0);
-    var fs = util.fs();
+    const buffer = Buffer.alloc(0);
+    const fs = util.fs();
 
     fs.open('/myfile', 'w+', function(error, result) {
       if(error) throw error;
 
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
 

tests/spec/fs.exists.spec.js

@@ -1,17 +1,18 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.exists', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.exists).to.equal('function');
   });
 
   it('should return false if path does not exist', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.exists('/tmp', function(result) {
       expect(result).to.be.false;
@@ -20,7 +21,7 @@ describe('fs.exists', function() {
   });
 
   it('should return true if path exists', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(err, fd) {
       if(err) throw err;
@@ -37,7 +38,7 @@ describe('fs.exists', function() {
   });
 
   it('should follow symbolic links and return true for the resulting path', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, fd) {
       if(error) throw error;
@@ -58,7 +59,7 @@ describe('fs.exists', function() {
   });
   
   it('should follow symbolic links and return false if for the resulting path does not exist', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, fd) {
       if(error) throw error;

tests/spec/fs.lstat.spec.js

@@ -1,18 +1,19 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.lstat', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.lstat).to.equal('function');
   });
 
   it('should return an error if path does not exist', function(done) {
-    var fs = util.fs();
-
+    const fs = util.fs();
+    
     fs.lstat('/tmp', function(error, result) {
       expect(error).to.exist;
       expect(error.code).to.equal('ENOENT');
@@ -22,8 +23,8 @@ describe('fs.lstat', function() {
   });
 
   it('should return a stat object if path is not a symbolic link', function(done) {
-    var fs = util.fs();
-
+    const fs = util.fs();
+    
     fs.lstat('/', function(error, result) {
       expect(error).not.to.exist;
       expect(result).to.exist;
@@ -33,8 +34,8 @@ describe('fs.lstat', function() {
   });
 
   it('should return a stat object if path is a symbolic link', function(done) {
-    var fs = util.fs();
-
+    const fs = util.fs();
+    
     fs.symlink('/', '/mylink', function(error) {
       if(error) throw error;
 
@@ -46,6 +47,27 @@ describe('fs.lstat', function() {
       });
     });
   });
+
+  it('should have a mode (full node) when stat\'d with lstat', function(done) {
+    var fs = util.fs();
+
+    fs.writeFile('/file', 'data', function(error) {
+      if(error) throw error;
+
+      fs.symlink('/file', '/symlink', function(error) {
+        if(error) throw error;
+
+        fs.lstat('/symlink', function(error, stats) {
+          if(error) throw error;
+
+          // We should build and return a full node object, complete with
+          // calculated mode, which should be a SYMLINK and the default file permissions.
+          expect(stats.mode).to.equal(fs.constants.S_IFLNK | 0o644);
+          done();
+        });
+      });
+    });
+  });
 });
 
 describe('fs.promises.lstat', () => {
@@ -53,7 +75,7 @@ describe('fs.promises.lstat', () => {
   afterEach(util.cleanup);
 
   it('should return an error if path does not exist', () => {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;   
     
     return fsPromises.lstat('/tmp')
       .catch( error => {
@@ -63,8 +85,8 @@ describe('fs.promises.lstat', () => {
   });
 
   it('should return a stat object if path is not a symbolic link', () => {
-    var fsPromises = util.fs().promises;
-
+    const fsPromises = util.fs().promises;
+    
     return fsPromises.lstat('/')
       .then(result => {
         expect(result).to.exist;

tests/spec/fs.mkdir.spec.js

@@ -1,17 +1,18 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.mkdir', function () {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function () {
-    var fs = util.fs();
+    const 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 (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/tmp/mydir', function (error) {
       expect(error).to.exist;
@@ -21,7 +22,7 @@ describe('fs.mkdir', function () {
   });
 
   it('should return an error if the path already exists', function (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/', function (error) {
       expect(error).to.exist;
@@ -31,7 +32,7 @@ describe('fs.mkdir', function () {
   });
 
   it('should make a new directory', function (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/tmp', function (error) {
       expect(error).not.to.exist;
@@ -52,12 +53,12 @@ describe('fs.promises.mkdir', function () {
   afterEach(util.cleanup);
 
   it('should be a function', function () {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.promises.mkdir).to.be.a('function');
   });
 
   it('should return an error if part of the parent path does not exist', function () {
-    var fs = util.fs();
+    const fs = util.fs();
 
     return fs.promises.mkdir('/tmp/mydir')
       .catch(error => {
@@ -67,7 +68,7 @@ describe('fs.promises.mkdir', function () {
   });
 
   it('should return an error if the path already exists', function () {
-    var fs = util.fs();
+    const fs = util.fs();
 
     return fs.promises.mkdir('/')
       .catch(error =>{
@@ -77,7 +78,7 @@ describe('fs.promises.mkdir', function () {
   });
 
   it('should make a new directory', function () {
-    var fs = util.fs();
+    const fs = util.fs();
 
     return fs.promises.mkdir('/tmp')
       .then(() => fs.promises.stat('/tmp'))
@@ -88,7 +89,7 @@ describe('fs.promises.mkdir', function () {
   });
 
   it('should return a promise', function () {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.promises.mkdir('/tmp')).to.be.a('promise');
   });
 });

tests/spec/fs.mkdtemp.spec.js

@@ -1,17 +1,19 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.mkdtemp', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.mkdtemp).to.be.a('function');
   });
 
   it('should craete temp dir with specified prefix', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.mkdtemp('/foo', function(error, path) {
       expect(error).not.to.exist;
       expect(path).to.match(/foo-\w{6}/);
@@ -20,7 +22,7 @@ describe('fs.mkdtemp', function() {
   });
 
   it('should craete temp dir inside existing directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.mkdir('/myDir', (error) => {
       expect(error).not.to.exist;
       fs.mkdtemp('/myDir/foo', function(error, path) {
@@ -32,7 +34,7 @@ describe('fs.mkdtemp', function() {
   });
 
   it('should not create temp dir without prefix', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.mkdtemp('', function(error, path) {
       expect(error).to.exist;
       expect(path).not.to.exist;
@@ -41,7 +43,7 @@ describe('fs.mkdtemp', function() {
   });
   
   it('should not create temp dir inside non existing dir', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.mkdtemp('/doesNotExists/foo', function(error, path) {
       expect(error).to.exist;
       expect(error.code).to.be.equal('ENOENT');
@@ -49,4 +51,4 @@ describe('fs.mkdtemp', function() {
       done();
     });
   });
-});
+});

tests/spec/fs.open.spec.js

@@ -47,6 +47,23 @@ describe('fs.open', function() {
     });
   });
 
+  it('should return an error when flagged for write and the path exists', function(done) {
+    var fs = util.fs();
+
+    fs.mkdir('/tmp', function(error) {
+      if(error) throw error;
+      fs.writeFile('/tmp/file', 'data', function(error) {
+        if(error) throw error;
+        fs.open('/tmp/file', 'wx', function(error, result) {
+          expect(error).to.exist;
+          expect(error.code).to.equal('EEXIST');
+          expect(result).not.to.exist;
+          done();
+        });
+      });
+    });
+  });
+
   it('should return an error when flagged for append and the path is a directory', function(done) {
     var fs = util.fs();
 

tests/spec/fs.read.spec.js

@@ -1,19 +1,20 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.read', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.read).to.be.a('function');
   });
 
   it('should read data from a file', function(done) {
-    var fs = util.fs();
-    var wbuffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
-    var rbuffer = Buffer.alloc(wbuffer.length);
+    const fs = util.fs();
+    const wbuffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    const rbuffer = Buffer.alloc(wbuffer.length);
 
     fs.open('/myfile', 'w+', function(error, fd) {
       if(error) throw error;
@@ -33,10 +34,10 @@ describe('fs.read', function() {
   });
 
   it('should update the current file position', function(done) {
-    var fs = util.fs();
-    var wbuffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
-    var rbuffer = Buffer.alloc(wbuffer.length);
-    var _result = 0;
+    const fs = util.fs();
+    const wbuffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    const rbuffer = Buffer.alloc(wbuffer.length);
+    let _result = 0;
 
     fs.open('/myfile', 'w+', function(error, fd) {
       if(error) throw error;
@@ -63,9 +64,9 @@ describe('fs.read', function() {
   });
 
   it('should fail to read a directory', function(done) {
-    var fs = util.fs();
-    var buf = Buffer.alloc(20);
-    var buf2 = Buffer.alloc(20);
+    const fs = util.fs();
+    const buf = Buffer.alloc(20);
+    const buf2 = Buffer.alloc(20);
 
     fs.mkdir('/mydir', function(error) {
       if(error) throw error;
@@ -85,10 +86,10 @@ describe('fs.read', function() {
   });
 
   it('should fail to read a file that does not exist', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
-    var fd = 0;
-    var rbuffer = Buffer.alloc(8);
+    const fd = 0;
+    const rbuffer = Buffer.alloc(8);
 
     fs.read(fd, rbuffer, 0, rbuffer.length, 0, function(error, result) {
       expect(error).to.exist;

tests/spec/fs.readdir.spec.js

@@ -1,17 +1,19 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict'; 
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.readdir', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.readdir).to.be.a('function');
   });
 
   it('should return an error if the path does not exist', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.readdir('/tmp/mydir', function(error, files) {
       expect(error).to.exist;
@@ -22,7 +24,7 @@ describe('fs.readdir', function() {
   });
 
   it('should return a list of files from an existing directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/tmp', function(error) {
       if(error) throw error;
@@ -38,7 +40,7 @@ describe('fs.readdir', function() {
   });
 
   it('should follow symbolic links', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/tmp', function(error) {
       if(error) throw error;
@@ -56,12 +58,12 @@ describe('fs.readdir', function() {
   });
 
   it('(promise) should be a function', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
     expect(fsPromises.readdir).to.be.a('function');
   });
 
   it('should return an error if the path is a file', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
 
     return fsPromises.writeFile('/myfile', 'contents')
       .then(() => fsPromises.readdir('/myfile'))
@@ -72,7 +74,7 @@ describe('fs.readdir', function() {
   });
 
   it('(promise) should return a list of files from an existing directory', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
 
     return fsPromises.mkdir('/tmp')
       .then(() => {

tests/spec/fs.readlink.spec.js

@@ -1,42 +1,59 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
 
-describe('fs.readlink', function() {
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
+
+describe('fs.readlink', function () {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
-  it('should be a function', function() {
-    var fs = util.fs();
+  it('should be a function', function () {
+    const 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(done) {
-    var fs = util.fs();
+  it('should return an error if part of the parent destination path does not exist', function (done) {
+    const fs = util.fs();
 
-    fs.readlink('/tmp/mydir', function(error) {
+    fs.readlink('/tmp/mydir', function (error) {
       expect(error).to.exist;
       expect(error.code).to.equal('ENOENT');
       done();
     });
   });
 
-  it('should return an error if the path is not a symbolic link', function(done) {
-    var fs = util.fs();
+  it('should return an error if the path is not a symbolic link', function (done) {
+    const fs = util.fs();
 
-    fs.readlink('/', function(error) {
+    fs.readlink('/', function (error) {
       expect(error).to.exist;
       expect(error.code).to.equal('ENOENT');
       done();
     });
   });
 
-  it('should return the contents of a symbolic link', function(done) {
-    var fs = util.fs();
+  it('should return an error if the path is not a symbolic link', function (done) {
+    const fs = util.fs();
 
-    fs.symlink('/', '/myfile', function(error) {
-      if(error) throw error;
+    fs.mkdir('/tmp', function (error) {
+      if (error) throw error;
 
-      fs.readlink('/myfile', function(error, result) {
+      fs.readlink('/tmp', function (error) {
+        expect(error).to.exist;
+        expect(error.code).to.equal('EINVAL');
+        done();
+      });
+
+    });
+  });
+
+  it('should return the contents of a symbolic link', function (done) {
+    const fs = util.fs();
+
+    fs.symlink('/', '/myfile', function (error) {
+      if (error) throw error;
+
+      fs.readlink('/myfile', function (error, result) {
         expect(error).not.to.exist;
         expect(result).to.equal('/');
         done();
@@ -44,24 +61,24 @@ describe('fs.readlink', function() {
     });
   });
 
-  it('should allow relative paths, but resolve to the dstpath', function(done) {
-    var fs = util.fs();
-    var contents = 'contents';
+  it('should allow relative paths, but resolve to the dstpath', function (done) {
+    const fs = util.fs();
+    const contents = 'contents';
 
-    fs.mkdir('/dir', function(error) {
-      if(error) throw error;
+    fs.mkdir('/dir', function (error) {
+      if (error) throw error;
 
-      fs.writeFile('/file', contents, function(error) {
-        if(error) throw error;
+      fs.writeFile('/file', contents, function (error) {
+        if (error) throw error;
 
-        fs.symlink('../file', '/dir/symlink', function(error) {
-          if(error) throw error;
+        fs.symlink('../file', '/dir/symlink', function (error) {
+          if (error) throw error;
 
-          fs.readlink('/dir/symlink', function(error, result) {
+          fs.readlink('/dir/symlink', function (error, result) {
             expect(error).not.to.exist;
             expect(result).to.equal('../file');
 
-            fs.readFile('/dir/symlink', 'utf8', function(error, data) {
+            fs.readFile('/dir/symlink', 'utf8', function (error, data) {
               expect(error).not.to.exist;
               expect(data).to.equal(contents);
               done();

tests/spec/fs.rename.spec.js

@@ -20,7 +20,7 @@ describe('fs.rename', function() {
         if(error) throw error;
 
         fs.rename('/myfile', '/myfile', function(error) {
-          expect(error).not.to.exist; 
+          expect(error).not.to.exist;
           done();
         });
       });
@@ -108,6 +108,35 @@ describe('fs.rename', function() {
       });
   });
 
+  it('should rename an existing directory into another sub directory', () => {
+    var fsPromises = util.fs().promises;
+
+    return fsPromises.mkdir('/mydir')
+      .then(() => fsPromises.mkdir('/mydir/subdir'))
+      .then(() => fsPromises.mkdir('/anotherdir'))
+      .then(() => fsPromises.rename('/mydir', '/anotherdir/originaldir'))
+      .then(() => { fsPromises.stat('/mydir')
+        .catch((error) => {
+          expect(error).to.exist;
+          expect(error.code).to.equal('ENOENT');
+        });
+      })
+      .then(() => { fsPromises.stat('/anotherdir/mydir')
+        .catch((error) => {
+          expect(error).to.exist;
+          expect(error.code).to.equal('ENOENT');
+        });
+      })
+      .then(() => { fsPromises.stat('/anotherdir/originaldir/subdir')
+        .then(result => {
+          expect(result.nlinks).to.equal(1);
+        });
+      })
+      .catch((error) => {
+        if (error) throw error;
+      });
+  });
+
   it('should rename an existing directory if the new path points to an existing directory', function(done) {
     var fs = util.fs();
 

tests/spec/fs.shell.spec.js

@@ -1,26 +1,28 @@
-var Filer = require('../../src');
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const Filer = require('../../src');
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.Shell', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('is a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.Shell).to.equal('function');
   });
 
   it('should return a FileSystemShell instance', function() {
-    var fs = util.fs();
-    var sh = new fs.Shell();
+    const fs = util.fs();
+    const sh = new fs.Shell();
 
     expect(sh.prototype).to.deep.equal((new Filer.Shell(fs)).prototype);
   });
 
   it('should reflect changes to the prototype', function(){
-    var fs = util.fs();
-    var sh = new fs.Shell();
+    const fs = util.fs();
+    const sh = new fs.Shell();
 
     Filer.Shell.prototype.test = 'foo';
 

tests/spec/fs.spec.js

@@ -1,19 +1,21 @@
-var Filer = require('../../src');
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const Filer = require('../../src');
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('is an object', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs).to.equal('object');
     expect(fs).to.be.an.instanceof(Filer.FileSystem);
   });
 
   it('should have a root directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.stat('/', function(error, result) {
       expect(error).not.to.exist;
       expect(result).to.exist;

tests/spec/fs.stat.spec.js

@@ -1,5 +1,8 @@
 var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+var chai = require('chai');
+chai.use(require('chai-datetime'));
+var expect = chai.expect;
+var Path = require('../../src').Path;
 
 describe('fs.stat', function() {
   beforeEach(util.setup);
@@ -55,9 +58,9 @@ describe('fs.stat', function() {
       expect(result['mtime']).to.be.a('date');
       expect(result['ctime']).to.be.a('date');
 
-      expect(result.atime.getTime()/1000).to.equal(result.atimeMs);
-      expect(result.mtime.getTime()/1000).to.equal(result.mtimeMs);
-      expect(result.ctime.getTime()/1000).to.equal(result.ctimeMs);
+      expect(result.atime.getTime()).to.equal(result.atimeMs);
+      expect(result.mtime.getTime()).to.equal(result.mtimeMs);
+      expect(result.ctime.getTime()).to.equal(result.ctimeMs);
 
       done();
     });
@@ -152,6 +155,352 @@ describe('fs.stat', function() {
         expect(result.isDirectory()).to.be.true;
       }); 
   });
+
+  it('should set appropriate time and timeMs values when creating a file', function(done) {
+    var fs = util.fs();
+
+    // Make sure that all times on a file node are within a 1 minute window
+    var before = new Date();
+    var oneMinuteLater = new Date();
+    oneMinuteLater.setMinutes(oneMinuteLater.getMinutes() + 1);
+
+    fs.writeFile('/file', 'data', function(error) {
+      if(error) throw error;
+
+      fs.stat('/file', function(error, stats) {
+        if(error) throw error;
+
+        expect(new Date(stats.ctimeMs)).to.be.withinDate(before, oneMinuteLater);
+        expect(stats.ctime).to.be.withinDate(before, oneMinuteLater);
+
+        expect(new Date(stats.atimeMs)).to.be.withinDate(before, oneMinuteLater);
+        expect(stats.atime).to.be.withinDate(before, oneMinuteLater);
+
+        expect(new Date(stats.mtimeMs)).to.be.withinDate(before, oneMinuteLater);
+        expect(stats.mtime).to.be.withinDate(before, oneMinuteLater);
+
+        done();
+      });
+    });
+  });
+
+  it('should set appropriate time and timeMs values when creating a file', function(done) {
+    var fs = util.fs();
+
+    fs.writeFile('/file', 'data', function(error) {
+      if(error) throw error;
+
+      var newAtime = new Date('1 Oct 2000 15:33:22');
+      var newMtime = new Date('30 Sep 2000 06:43:54');
+
+      fs.utimes('/file', newAtime, newMtime, function(error) {
+        if(error) throw error;
+
+        fs.stat('/file', function(error, stats) {
+          if(error) throw error;
+
+          // ctime should match newMtime
+          expect(stats.ctimeMs).to.equal(newMtime.getTime());
+          expect(stats.ctime).to.equalDate(newMtime);
+
+          // atime should match newAtime
+          expect(stats.atimeMs).to.equal(newAtime.getTime());
+          expect(stats.atime).to.equalDate(newAtime);
+
+          // mtime should match newMtime
+          expect(stats.mtimeMs).to.equal(newMtime.getTime());
+          expect(stats.mtime).to.equalDate(newMtime);
+
+          done();
+        });
+      });
+    });
+  });
+
+  describe('fs.stats', function() {
+    describe('#isFile()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isFile).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return true if stats are for file', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+  
+          fs.fstat(fd, function(error, stats) {
+            expect(error).not.to.exist;
+            expect(stats.isFile()).to.be.true;
+            fs.close(fd, done);
+          });
+        });
+      });
+  
+      it('should return false if stats are for directory', function(done) {
+        var fs = util.fs();
+  
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isFile()).to.be.false;
+          done();
+        });
+      });
+  
+      it('should return false if stats are for symbolic link', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+  
+          fs.close(fd, function(error) {
+            if(error) throw error;
+  
+            fs.symlink('/myfile', '/myfilelink', function(error) {
+              if(error) throw error;
+              fs.lstat('/myfilelink', function(error, stats) {
+                expect(error).not.to.exist;
+                expect(stats.isFile()).to.be.false;
+                done();
+              });
+            });
+          });
+        });
+      });
+    });
+  
+    describe('#isDirectory()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isDirectory).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false if stats are for file', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+          fs.fstat(fd, function(error, stats) {
+            expect(error).not.to.exist;
+            expect(stats.isDirectory()).to.be.false;
+            fs.close(fd, done);
+          });
+        });
+      });
+  
+      it('should return true if stats are for directory', function(done) {
+        var fs = util.fs();
+  
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isDirectory()).to.be.true;
+          done();
+        });
+      });
+  
+      it('should return false if stats are for symbolic link', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+          fs.close(fd, function(error) {
+            if(error) throw error;
+            fs.symlink('/myfile', '/myfilelink', function(error) {
+              if(error) throw error;
+              fs.lstat('/myfilelink', function(error, stats) {
+                expect(stats.isDirectory()).to.be.false;
+                done();
+              });
+            });
+          });
+        });
+      });
+    });
+  
+    describe('#isBlockDevice()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isBlockDevice).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isBlockDevice()).to.be.false;
+          done();
+        });
+      });
+    });
+  
+    describe('#isCharacterDevice()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isCharacterDevice).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isCharacterDevice()).to.be.false;
+          done();
+        });
+      });
+    });
+  
+    describe('#isSymbolicLink()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isSymbolicLink).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false if stats are for file', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+          fs.fstat(fd, function(error, stats) {
+            expect(error).not.to.exist;
+            expect(stats.isSymbolicLink()).to.be.false;
+            fs.close(fd, done);
+          });
+        });
+      });
+  
+      it('should return false if stats are for directory', function(done) {
+        var fs = util.fs();
+  
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isSymbolicLink()).to.be.false;
+          done();
+        });
+      });
+  
+      it('should return true if stats are for symbolic link', function(done) {
+        var fs = util.fs();
+  
+        fs.open('/myfile', 'w+', function(error, fd) {
+          if(error) throw error;
+          fs.close(fd, function(error) {
+            if(error) throw error;
+            fs.symlink('/myfile', '/myfilelink', function(error) {
+              if(error) throw error;
+              fs.lstat('/myfilelink', function(error, stats) {
+                expect(stats.isSymbolicLink()).to.be.true;
+                done();
+              });
+            });
+          });
+        });
+      });
+    });
+  
+    describe('#isFIFO()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isFIFO).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isFIFO()).to.be.false;
+          done();
+        });
+      });
+    });
+  
+    describe('#isSocket()', function() {
+  
+      it('should be a function', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isSocket).to.be.a('function');
+          done();
+        });
+      });
+  
+      it('should return false', function(done) {
+        var fs = util.fs();
+        fs.stat('/', function(error, stats) {
+          if(error) throw error;
+          expect(stats.isSocket()).to.be.false;
+          done();
+        });
+      });
+    });
+  
+    describe('generated name property', function() {
+      
+      it('should correct return name for a file', function(done) {
+        var fs = util.fs();
+        var filepath = '/a';
+  
+        fs.writeFile(filepath, 'data', function(err) {
+          if(err) throw err;
+  
+          fs.stat(filepath, function(err, stats) {
+            if(err) throw err;
+  
+            expect(stats.name).to.equal(Path.basename(filepath));
+            done();
+          });
+        });
+      });
+  
+      it('should correct return name for an fd', function(done) {
+        var fs = util.fs();
+        var filepath = '/a';
+  
+        fs.open(filepath, 'w', function(err, fd) {
+          if(err) throw err;
+  
+          fs.fstat(fd, function(err, stats) {
+            if(err) throw err;
+  
+            expect(stats.name).to.equal(Path.basename(filepath));
+            fs.close(fd, done);
+          });
+        });
+      });
+    });
+  });
+  
 });
 
 /**

tests/spec/fs.stats.spec.js

@@ -1,303 +0,0 @@
-var Path = require('../../src').Path;
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
-
-describe('fs.stats', function() {
-  describe('#isFile()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isFile).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return true if stats are for file', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-
-        fs.fstat(fd, function(error, stats) {
-          expect(error).not.to.exist;
-          expect(stats.isFile()).to.be.true;
-          fs.close(fd, done);
-        });
-      });
-    });
-
-    it('should return false if stats are for directory', function(done) {
-      var fs = util.fs();
-
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isFile()).to.be.false;
-        done();
-      });
-    });
-
-    it('should return false if stats are for symbolic link', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-
-        fs.close(fd, function(error) {
-          if(error) throw error;
-
-          fs.symlink('/myfile', '/myfilelink', function(error) {
-            if(error) throw error;
-            fs.lstat('/myfilelink', function(error, stats) {
-              expect(error).not.to.exist;
-              expect(stats.isFile()).to.be.false;
-              done();
-            });
-          });
-        });
-      });
-    });
-  });
-
-  describe('#isDirectory()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isDirectory).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false if stats are for file', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-        fs.fstat(fd, function(error, stats) {
-          expect(error).not.to.exist;
-          expect(stats.isDirectory()).to.be.false;
-          fs.close(fd, done);
-        });
-      });
-    });
-
-    it('should return true if stats are for directory', function(done) {
-      var fs = util.fs();
-
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isDirectory()).to.be.true;
-        done();
-      });
-    });
-
-    it('should return false if stats are for symbolic link', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-        fs.close(fd, function(error) {
-          if(error) throw error;
-          fs.symlink('/myfile', '/myfilelink', function(error) {
-            if(error) throw error;
-            fs.lstat('/myfilelink', function(error, stats) {
-              expect(stats.isDirectory()).to.be.false;
-              done();
-            });
-          });
-        });
-      });
-    });
-  });
-
-  describe('#isBlockDevice()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isBlockDevice).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isBlockDevice()).to.be.false;
-        done();
-      });
-    });
-  });
-
-  describe('#isCharacterDevice()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isCharacterDevice).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isCharacterDevice()).to.be.false;
-        done();
-      });
-    });
-  });
-
-  describe('#isSymbolicLink()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isSymbolicLink).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false if stats are for file', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-        fs.fstat(fd, function(error, stats) {
-          expect(error).not.to.exist;
-          expect(stats.isSymbolicLink()).to.be.false;
-          fs.close(fd, done);
-        });
-      });
-    });
-
-    it('should return false if stats are for directory', function(done) {
-      var fs = util.fs();
-
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isSymbolicLink()).to.be.false;
-        done();
-      });
-    });
-
-    it('should return true if stats are for symbolic link', function(done) {
-      var fs = util.fs();
-
-      fs.open('/myfile', 'w+', function(error, fd) {
-        if(error) throw error;
-        fs.close(fd, function(error) {
-          if(error) throw error;
-          fs.symlink('/myfile', '/myfilelink', function(error) {
-            if(error) throw error;
-            fs.lstat('/myfilelink', function(error, stats) {
-              expect(stats.isSymbolicLink()).to.be.true;
-              done();
-            });
-          });
-        });
-      });
-    });
-  });
-
-  describe('#isFIFO()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isFIFO).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isFIFO()).to.be.false;
-        done();
-      });
-    });
-  });
-
-  describe('#isSocket()', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-
-    it('should be a function', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isSocket).to.be.a('function');
-        done();
-      });
-    });
-
-    it('should return false', function(done) {
-      var fs = util.fs();
-      fs.stat('/', function(error, stats) {
-        if(error) throw error;
-        expect(stats.isSocket()).to.be.false;
-        done();
-      });
-    });
-  });
-
-  describe('generated name property', function() {
-    beforeEach(util.setup);
-    afterEach(util.cleanup);
-    
-    it('should correct return name for a file', function(done) {
-      var fs = util.fs();
-      var filepath = '/a';
-
-      fs.writeFile(filepath, 'data', function(err) {
-        if(err) throw err;
-
-        fs.stat(filepath, function(err, stats) {
-          if(err) throw err;
-
-          expect(stats.name).to.equal(Path.basename(filepath));
-          done();
-        });
-      });
-    });
-
-    it('should correct return name for an fd', function(done) {
-      var fs = util.fs();
-      var filepath = '/a';
-
-      fs.open(filepath, 'w', function(err, fd) {
-        if(err) throw err;
-
-        fs.fstat(fd, function(err, stats) {
-          if(err) throw err;
-
-          expect(stats.name).to.equal(Path.basename(filepath));
-          fs.close(fd, done);
-        });
-      });
-    });
-  });
-});

tests/spec/fs.symlink.spec.js

@@ -1,17 +1,19 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict'; 
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.symlink', function () {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function () {
-    var fs = util.fs();
+    const 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 (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.symlink('/', '/tmp/mydir', function (error) {
       expect(error).to.exist;
@@ -21,7 +23,7 @@ describe('fs.symlink', function () {
   });
 
   it('should return an error if the destination path already exists', function (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.symlink('/tmp', '/', function (error) {
       expect(error).to.exist;
@@ -31,7 +33,7 @@ describe('fs.symlink', function () {
   });
 
   it('should create a symlink', function (done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.symlink('/', '/myfile', function (error) {
       expect(error).not.to.exist;
@@ -44,10 +46,40 @@ describe('fs.symlink', function () {
     });
   });
 
+  it('should return the same node data for a file and symbolic link', function(done) {
+    var fs = util.fs();
+
+    fs.writeFile('/file', 'data', function(error) {
+      if(error) throw error;
+
+      fs.stat('/file', function(error, stats1) {
+        if(error) throw error;
+
+
+        fs.symlink('/file', '/symlink', function(error) {
+          if(error) throw error;
+
+          fs.stat('/symlink', function(error, stats2) {
+            if(error) throw error;
+
+            // The node names will differ, confirm and remove.
+            expect(stats1.name).to.equal('file');
+            delete stats1.name;
+            expect(stats2.name).to.equal('symlink');
+            delete stats2.name;
+
+            expect(stats2).to.deep.equal(stats1);
+            done();
+          });
+        });
+      });
+    });
+  });
+
   /** Tests for fsPromises API */
   describe('fsPromises.symlink', function () {
     it('should return an error if destination path does not exist', function () {
-      var fsPromises = util.fs().promises;
+      const fsPromises = util.fs().promises;
   
       return fsPromises.symlink('/', '/tmp/link')
         .catch(error => {
@@ -57,7 +89,7 @@ describe('fs.symlink', function () {
     });
 
     it('should return an error if source path does not exist', function () {
-      var fsPromises = util.fs().promises;
+      const fsPromises = util.fs().promises;
   
       return fsPromises.symlink('/tmp/myLink', '/myLink')
         .catch(error => {
@@ -67,7 +99,7 @@ describe('fs.symlink', function () {
     });
 
     it('Promise should create a symlink of type DIRECTORY when directory provided', function () {
-      var fsPromises = util.fs().promises;
+      const fsPromises = util.fs().promises;
   
       return fsPromises.symlink('/', '/myDirLink')
         .then(() => fsPromises.stat('/myDirLink'))
@@ -78,7 +110,7 @@ describe('fs.symlink', function () {
     });
 
     it('Promise should create a symlink of type FILE when file provided', function () {
-      var fsPromises = util.fs().promises;
+      const fsPromises = util.fs().promises;
 
       return fsPromises.writeFile('/myFile', 'data')
         .then(() => fsPromises.symlink('/myFile', '/myFileLink'))
@@ -90,7 +122,7 @@ describe('fs.symlink', function () {
     });
 
     it('Promise should return an error if the destination path already exists', function () {
-      var fsPromises = util.fs().promises;
+      const fsPromises = util.fs().promises;
 
       return fsPromises.symlink('/tmp', '/')
         .catch(error => {
@@ -108,7 +140,7 @@ describe('fsPromises.symlink', function () {
 
 
   it('should return an error if part of the parent destination path does not exist', () => {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
 
     return fsPromises.symlink('/', '/tmp/mydir')
       .catch(error => {

tests/spec/fs.unlink.spec.js

@@ -1,18 +1,18 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+let util = require('../lib/test-utils.js');
+let expect = require('chai').expect;
 
 describe('fs.unlink', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.unlink).to.be.a('function');
   });
 
   it('should remove a link to an existing file', function(done) {
-    var fs = util.fs();
-    var complete1, complete2;
+    let fs = util.fs();
+    let complete1, complete2;
 
     function maybeDone() {
       if(complete1 && complete2) {
@@ -53,7 +53,7 @@ describe('fs.unlink', function() {
   });
 
   it('should not follow symbolic links', function(done) {
-    var fs = util.fs();
+    let fs = util.fs();
 
     fs.symlink('/', '/myFileLink', function (error) {
       if (error) throw error;
@@ -85,7 +85,7 @@ describe('fs.unlink', function() {
   });
 
   it('should not unlink directories', function (done) {
-    var fs = util.fs();
+    let fs = util.fs();
 
     fs.mkdir('/mydir', function (error) {
       if(error) throw error;
@@ -110,12 +110,12 @@ describe('fs.promises.unlink', function () {
   afterEach(util.cleanup);
 
   it('should be a function', function () {
-    var fs = util.fs();
+    let fs = util.fs();
     expect(fs.promises.unlink).to.be.a('function');
   });
 
   it('should return an error if trying to delete a file that does not exist', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
 
     return fsPromises.unlink('/myFile')
       .catch(error => {
@@ -125,7 +125,7 @@ describe('fs.promises.unlink', function () {
   });
 
   it('should not unlink directories', () => {
-    var fs = util.fs().promises;
+    let fs = util.fs().promises;
 
     return fs.mkdir('/mydir')
       .then(() => fs.unlink('/mydir'))

tests/spec/fs.watch.spec.js

@@ -1,5 +1,7 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util   = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.watch', function() {
   // Our watch infrastucture is dependent on document.localStorage
@@ -16,14 +18,14 @@ describe('fs.watch', function() {
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(typeof fs.watch).to.equal('function');
   });
 
   it('should get a change event when writing a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
-    var watcher = fs.watch('/myfile', function(event, filename) {
+    const watcher = fs.watch('/myfile', function(event, filename) {
       expect(event).to.equal('change');
       expect(filename).to.equal('/myfile');
       watcher.close();
@@ -36,9 +38,9 @@ describe('fs.watch', function() {
   });
 
   it('should get a change event when writing a file beneath root dir with recursive=true', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
-    var watcher = fs.watch('/', { recursive: true }, function(event, filename) {
+    const watcher = fs.watch('/', { recursive: true }, function(event, filename) {
       expect(event).to.equal('change');
       expect(filename).to.equal('/');
       watcher.close();
@@ -51,12 +53,12 @@ describe('fs.watch', function() {
   });
 
   it('should get a change event when writing a file in a dir with recursive=true', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/foo', function(err) {
       if(err) throw err;
 
-      var watcher = fs.watch('/foo', { recursive: true }, function(event, filename) {
+      const watcher = fs.watch('/foo', { recursive: true }, function(event, filename) {
         expect(event).to.equal('change');
         expect(filename).to.equal('/foo');
         watcher.close();
@@ -77,7 +79,7 @@ describe('fs.watch', function() {
 
   // Bug to deal with this is filed at https://github.com/filerjs/filer/issues/594
   it.skip('should get a change event when a hardlink is watched and the original file is changed', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/myfile', 'data', function(error) {
       if(error) throw error;
@@ -85,7 +87,7 @@ describe('fs.watch', function() {
       fs.link('/myfile', '/hardlink', function(error) {
         if(error) throw error;
 
-        var watcher = fs.watch('/hardlink', function(event, filename) {
+        const watcher = fs.watch('/hardlink', function(event, filename) {
           expect(event).to.equal('change');
           expect(filename).to.equal('/hardlink');
 
@@ -107,14 +109,14 @@ describe('fs.watch', function() {
   });
 
   it('should get a change event when renaming a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/myfile', 'data', function(error) {
       if(error) throw error;
 
       //Normaly A 'rename' event should be thrown, but filer doesn't support that event at this time.
       //For now renaming a file will throw a change event.
-      var watcher = fs.watch('/myfile', function(event, filename) {
+      const watcher = fs.watch('/myfile', function(event, filename) {
         expect(event).to.equal('change');
         expect(filename).to.equal('/myfile');
         watcher.close();
@@ -126,4 +128,4 @@ describe('fs.watch', function() {
       });
     });
   });
-});
+});

tests/spec/fs.write.spec.js

@@ -1,24 +1,25 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.write', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.write).to.be.a('function');
   });
 
   it('should error if file path is undefined', function() {
-    var fs = util.fs();
-    var fn = () => fs.writeFile(undefined, 'data');
+    const fs = util.fs();
+    const fn = () => fs.writeFile(undefined, 'data');
     expect(fn).to.throw();
   });
 
   it('should write data to a file', function(done) {
-    var fs = util.fs();
-    var buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
     fs.open('/myfile', 'w', function(error, fd) {
       if(error) throw error;
@@ -38,9 +39,9 @@ describe('fs.write', function() {
   });
 
   it('should update the current file position', function(done) {
-    var fs = util.fs();
-    var buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
-    var _result = 0;
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    let _result = 0;
 
     fs.open('/myfile', 'w', function(error, fd) {
       if(error) throw error;
@@ -64,4 +65,49 @@ describe('fs.write', function() {
       });
     });
   });
+
+  it('should fail if given a file path vs. an fd', function(done) {
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+
+    fs.write('/myfile', buffer, 0, buffer.length, 0, function(error) {
+      expect(error).to.exist;
+      expect(error.code).to.equal('EBADF');
+      done();
+    });
+  });
+
+  it('should fail when trying to write more bytes than are available in the buffer (length too long)', function(done) {
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+
+    fs.open('/myfile', 'w', function(error, fd) {
+      if(error) throw error;
+
+      fs.write(fd, buffer, 0, (buffer.length + 10), 0, function(error) {
+        expect(error).to.exist;
+        expect(error.code).to.equal('EIO');
+        fs.close(fd, done);
+      });
+    });
+  });
+
+  it('should fail to write data to a file opened without the O_WRITE flag', function(done) {
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+
+    fs.mknod('/myfile', 'FILE', function(err) {
+      if (err) throw err;
+
+      fs.open('/myfile', 'r', function(error, fd) {
+        if(error) throw error;
+  
+        fs.write(fd, buffer, 0, buffer.length, 0, function(error) {
+          expect(error).to.exist;
+          expect(error.code).to.equal('EBADF');
+          done();
+        });
+      });
+    });
+  });
 });

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

@@ -1,18 +1,19 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.writeFile, fs.readFile', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fs = util.fs();
+    const 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(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.readFile('/no-such-file', 'utf8', function(error, data) {
       expect(error).to.exist;
@@ -24,7 +25,7 @@ describe('fs.writeFile, fs.readFile', function() {
 
   
   it('should error when path is wrong to writeFile',function(done){
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/tmp/myfile', '','utf8', function(error, result) {
       expect(error).to.exist;
@@ -36,8 +37,8 @@ describe('fs.writeFile, fs.readFile', function() {
   });
 
   it('should write, read a utf8 file without specifying utf8 in writeFile', function(done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, function(error) {
       if(error) throw error;
@@ -50,8 +51,8 @@ describe('fs.writeFile, fs.readFile', function() {
   });
 
   it('should write, read a utf8 file with "utf8" option to writeFile', function(done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, 'utf8', function(error) {
       if(error) throw error;
@@ -64,8 +65,8 @@ describe('fs.writeFile, fs.readFile', function() {
   });
 
   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.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', contents, { encoding: 'utf8' }, function(error) {
       if(error) throw error;
@@ -78,9 +79,9 @@ describe('fs.writeFile, fs.readFile', function() {
   });
 
   it('should write, read a binary file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
     // String and utf8 binary encoded versions of the same thing: 'This is a file.'
-    var binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
+    const binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
 
     fs.writeFile('/myfile', binary, function(error) {
       if(error) throw error;
@@ -93,8 +94,8 @@ describe('fs.writeFile, fs.readFile', function() {
   });
 
   it('should follow symbolic links', function(done) {
-    var fs = util.fs();
-    var contents = 'This is a file.';
+    const fs = util.fs();
+    const contents = 'This is a file.';
 
     fs.writeFile('/myfile', '', { encoding: 'utf8' }, function(error) {
       if(error) throw error;
@@ -122,16 +123,16 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   afterEach(util.cleanup);
 
   it('should be a function', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
     expect(fsPromises.writeFile).to.be.a('function');
     expect(fsPromises.readFile).to.be.a('function');
   });
 
   it('should return a promise', function() {
-    var fsPromises = util.fs().promises;
-    var contents = 'This is a file.';
+    const fsPromises = util.fs().promises;
+    const contents = 'This is a file.';
 
-    var p = fsPromises.writeFile('/myfile', contents);
+    const p = fsPromises.writeFile('/myfile', contents);
     expect(p).to.be.a('Promise');
 
     p.then(() => {
@@ -141,7 +142,7 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should error when path is wrong to readFile', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
 
     return fsPromises.readFile('/no-such-file', 'utf8')
       .catch(error => { 
@@ -151,8 +152,8 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should write, read a utf8 file without specifying utf8 in writeFile', function() {
-    var fsPromises = util.fs().promises;
-    var contents = 'This is a file.';
+    const fsPromises = util.fs().promises;
+    const contents = 'This is a file.';
 
     return fsPromises.writeFile('/myfile', contents)
       .then( () => fsPromises.readFile('/myfile', 'utf8'))
@@ -160,8 +161,8 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should write, read a utf8 file with "utf8" option to writeFile', function() {
-    var fsPromises = util.fs().promises;
-    var contents = 'This is a file.';
+    const fsPromises = util.fs().promises;
+    const contents = 'This is a file.';
 
     return fsPromises.writeFile('/myfile', contents, 'utf8') 
       .then( () => fsPromises.readFile('/myfile', 'utf8'))
@@ -169,8 +170,8 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should write, read a utf8 file with {encoding: "utf8"} option to writeFile', function() {
-    var fsPromises = util.fs().promises;
-    var contents = 'This is a file.';
+    const fsPromises = util.fs().promises;
+    const contents = 'This is a file.';
 
     return fsPromises.writeFile('/myfile', contents, { encoding: 'utf8' })
       .then( () => fsPromises.readFile('/myfile', 'utf8'))
@@ -178,9 +179,9 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should write, read a binary file', function() {
-    var fsPromises = util.fs().promises;
+    const fsPromises = util.fs().promises;
     // String and utf8 binary encoded versions of the same thing: 'This is a file.'
-    var binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
+    const binary = Buffer.from([84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 102, 105, 108, 101, 46]);
 
     return fsPromises.writeFile('/myfile', binary)
       .then( () => fsPromises.readFile('/myfile'))
@@ -188,8 +189,8 @@ describe('fsPromises.writeFile, fsPromises.readFile', function() {
   });
 
   it('should follow symbolic links', function() {
-    var fsPromises = util.fs().promises;
-    var contents = 'This is a file.';
+    const fsPromises = util.fs().promises;
+    const contents = 'This is a file.';
 
     return fsPromises.writeFile('/myfile', '', { encoding: 'utf8' })
       .then( () => fsPromises.symlink('/myfile', '/myFileLink'))

tests/spec/fs.xattr.spec.js

@@ -1,12 +1,14 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('fs.xattr', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should be a function', function () {
-    var fs = util.fs();
+    const fs = util.fs();
     expect(fs.setxattr).to.be.a('function');
     expect(fs.getxattr).to.be.a('function');
     expect(fs.removexattr).to.be.a('function');
@@ -15,7 +17,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when setting with a name that is not a string', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -29,7 +31,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when setting with a name that is null', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -43,7 +45,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when setting with an invalid flag', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -57,7 +59,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when when setting an extended attribute which exists with XATTR_CREATE flag', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function(error) {
       if (error) throw error;
@@ -75,7 +77,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when setting an extended attribute which does not exist with XATTR_REPLACE flag', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function(error) {
       if (error) throw error;
@@ -89,7 +91,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when getting an attribute with a name that is empty', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function(error) {
       if (error) throw error;
@@ -104,7 +106,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when getting an attribute where the name is not a string', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function(error) {
       if (error) throw error;
@@ -119,7 +121,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when getting an attribute that does not exist', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function(error) {
       if (error) throw error;
@@ -134,10 +136,10 @@ describe('fs.xattr', function() {
   });
 
   it('should error when file descriptor is invalid', function(done) {
-    var fs = util.fs();
-    var completeSet = false;
-    var completeGet = false;
-    var completeRemove = false;
+    const fs = util.fs();
+    let completeSet = false;
+    let completeGet = false;
+    let completeRemove = false;
 
     function maybeDone() {
       if(completeSet && completeGet && completeRemove) {
@@ -170,8 +172,8 @@ describe('fs.xattr', function() {
   });
 
   it('should set and get an extended attribute of a path', function(done) {
-    var fs = util.fs();
-    var name = 'test';
+    const fs = util.fs();
+    const name = 'test';
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -189,7 +191,7 @@ describe('fs.xattr', function() {
   });
 
   it('should error when attempting to remove a non-existing attribute', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -207,7 +209,7 @@ describe('fs.xattr', function() {
   });
 
   it('should set and get an empty string as a value', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -225,7 +227,7 @@ describe('fs.xattr', function() {
   });
 
   it('should set and get an extended attribute for a valid file descriptor', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/testfile', 'w', function (error, ofd) {
       if (error) throw error;
@@ -243,7 +245,7 @@ describe('fs.xattr', function() {
   });
 
   it('should set and get an object to an extended attribute', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -261,7 +263,7 @@ describe('fs.xattr', function() {
   });
 
   it('should update/overwrite an existing extended attribute', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -296,7 +298,7 @@ describe('fs.xattr', function() {
   });
 
   it('should set multiple extended attributes for a path', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -323,7 +325,7 @@ describe('fs.xattr', function() {
   });
 
   it('should remove an extended attribute from a path', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -350,7 +352,7 @@ describe('fs.xattr', function() {
   });
 
   it('should remove an extended attribute from a valid file descriptor', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/testfile', 'w', function (error, ofd) {
       if (error) throw error;
@@ -377,7 +379,7 @@ describe('fs.xattr', function() {
   });
 
   it('should allow setting with a null value', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.writeFile('/testfile', '', function (error) {
       if (error) throw error;
@@ -393,4 +395,4 @@ describe('fs.xattr', function() {
       });
     });
   });
-});
+});

tests/spec/path-resolution.spec.js

@@ -1,16 +1,17 @@
-var Filer = require('../../src');
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const Filer = require('../../src');
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 // Support global URL and node's url module
-var URL = global.URL || require('url').URL;
+const URL = global.URL || require('url').URL;
 
 describe('path resolution', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
   it('should follow a symbolic link to the root directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.symlink('/', '/mydirectorylink', function(error) {
       if(error) throw error;
@@ -19,7 +20,7 @@ describe('path resolution', function() {
         if(error) throw error;
 
         expect(result['node']).to.exist;
-        var _node = result['node'];
+        const _node = result['node'];
 
         fs.stat('/mydirectorylink', function(error, result) {
           expect(error).not.to.exist;
@@ -32,7 +33,7 @@ describe('path resolution', function() {
   });
 
   it('should follow a symbolic link to a directory', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.mkdir('/mydir', function(error) {
       if(error) throw error;
@@ -44,7 +45,7 @@ describe('path resolution', function() {
           if(error) throw error;
 
           expect(result['node']).to.exist;
-          var _node = result['node'];
+          const _node = result['node'];
           fs.stat('/mydirectorylink', function(error, result) {
             expect(error).not.to.exist;
             expect(result).to.exist;
@@ -57,18 +58,18 @@ describe('path resolution', function() {
   });
 
   it('should follow a symbolic link to a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, result) {
       if(error) throw error;
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
         fs.stat('/myfile', function(error, result) {
           if(error) throw error;
 
           expect(result['node']).to.exist;
-          var _node = result['node'];
+          const _node = result['node'];
           fs.symlink('/myfile', '/myfilelink', function(error) {
             if(error) throw error;
 
@@ -85,18 +86,18 @@ describe('path resolution', function() {
   });
 
   it('should follow multiple symbolic links to a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, result) {
       if(error) throw error;
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
         fs.stat('/myfile', function(error, result) {
           if(error) throw error;
 
           expect(result['node']).to.exist;
-          var _node = result['node'];
+          const _node = result['node'];
           fs.symlink('/myfile', '/myfilelink1', function(error) {
             if(error) throw error;
             fs.symlink('/myfilelink1', '/myfilelink2', function(error) {
@@ -116,7 +117,7 @@ describe('path resolution', function() {
   });
 
   it('should error if symbolic link leads to itself', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.symlink('/mylink1', '/mylink2', function(error) {
       if(error) throw error;
@@ -135,8 +136,8 @@ describe('path resolution', function() {
   });
 
   it('should error if it follows more than 10 symbolic links', function(done) {
-    var fs = util.fs();
-    var nlinks = 11;
+    const fs = util.fs();
+    const nlinks = 11;
 
     function createSymlinkChain(n, callback) {
       if(n > nlinks) {
@@ -148,7 +149,7 @@ describe('path resolution', function() {
 
     fs.open('/myfile0', 'w', function(error, result) {
       if(error) throw error;
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
         fs.stat('/myfile0', function(error, result) {
@@ -170,17 +171,17 @@ describe('path resolution', function() {
   });
 
   it('should follow a symbolic link in the path to a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, result) {
       if(error) throw error;
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
         fs.stat('/myfile', function(error, result) {
           if(error) throw error;
 
-          var _node = result['node'];
+          const _node = result['node'];
           fs.symlink('/', '/mydirlink', function(error) {
             if(error) throw error;
 
@@ -198,11 +199,11 @@ describe('path resolution', function() {
   });
 
   it('should error if a symbolic link in the path to a file is itself a file', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     fs.open('/myfile', 'w', function(error, result) {
       if(error) throw error;
-      var fd = result;
+      const fd = result;
       fs.close(fd, function(error) {
         if(error) throw error;
         fs.stat('/myfile', function(error, result) {
@@ -211,7 +212,7 @@ describe('path resolution', function() {
 
           fs.open('/myfile2', 'w', function(error, result) {
             if(error) throw error;
-            var fd = result;
+            const fd = result;
             fs.close(fd, function(error) {
               if(error) throw error;
               fs.symlink('/myfile2', '/mynotdirlink', function(error) {
@@ -232,7 +233,7 @@ describe('path resolution', function() {
   });
 
   it('should properly add trailing slashes with Path.addTrailing()', function() {
-    var Path = Filer.Path;
+    const Path = Filer.Path;
     expect(Path.addTrailing('/')).to.equal('/');
     expect(Path.addTrailing('/////')).to.equal('/');
     expect(Path.addTrailing('.')).to.equal('./');
@@ -241,7 +242,7 @@ describe('path resolution', function() {
   });
 
   it('should properly remove trailing slashes with Path.removeTrailing()', function() {
-    var Path = Filer.Path;
+    const Path = Filer.Path;
     expect(Path.removeTrailing('/')).to.equal('/');
     expect(Path.removeTrailing('/////')).to.equal('/');
     expect(Path.removeTrailing('./')).to.equal('.');
@@ -250,10 +251,10 @@ describe('path resolution', function() {
   });
 
   it('should allow using Buffer for paths', function(done) {
-    var fs = util.fs();
-    var filePath = '/file';
-    var bufferPath = Buffer.from(filePath);
-    var data = 'data';
+    const fs = util.fs();
+    const filePath = '/file';
+    const bufferPath = Buffer.from(filePath);
+    const data = 'data';
 
     fs.writeFile(bufferPath, data, function(err) {
       if(err) throw err;
@@ -267,10 +268,10 @@ describe('path resolution', function() {
   });
 
   it('should allow using file: URLs for paths', function(done) {
-    var fs = util.fs();
-    var filePath = '/file';
-    var fileUrl = new URL(`file://${filePath}`);
-    var data = 'data';
+    const fs = util.fs();
+    const filePath = '/file';
+    const fileUrl = new URL(`file://${filePath}`);
+    const data = 'data';
 
     fs.writeFile(fileUrl, data, function(err) {
       if(err) throw err;
@@ -284,16 +285,16 @@ describe('path resolution', function() {
   });
 
   it('should error for non file: URLs for paths', function() {
-    var fs = util.fs();
-    var fileUrl = new URL('http://file');
-    var fn = () => fs.writeFile(fileUrl, 1);
+    const fs = util.fs();
+    const fileUrl = new URL('http://file');
+    const fn = () => fs.writeFile(fileUrl, 1);
     expect(fn).to.throw();
   });
 
   it('should error if file: URLs include escaped / characters', function() {
-    var fs = util.fs();
-    var fileUrl = new URL('file:///p/a/t/h/%2F');
-    var fn = () => fs.writeFile(fileUrl, 1);
+    const fs = util.fs();
+    const fileUrl = new URL('file:///p/a/t/h/%2F');
+    const fn = () => fs.writeFile(fileUrl, 1);
     expect(fn).to.throw();
   });
 });

tests/spec/shell/mkdirp.spec.js

@@ -30,6 +30,18 @@ describe('FileSystemShell.mkdirp', function() {
     });
   });
 
+  it('should succeed if provided path is root, given as a relative path (\'.\' in \'/\')', function(done) {
+    var fs = util.fs();
+    var shell = new fs.Shell();
+    shell.cd('/', function(err) {
+      expect(err).to.not.exist;
+      shell.mkdirp('.', function(err) {
+        expect(err).to.not.exist;
+        done();
+      });
+    });
+  });
+
   it('should succeed if the directory exists', function(done) {
     var fs = util.fs();
     var shell = new fs.Shell();
@@ -67,6 +79,21 @@ describe('FileSystemShell.mkdirp', function() {
     });
   });
 
+  it('should succeed on a folder given as a relative path (\'test\' in \'/\')', function(done) {
+    var fs = util.fs();
+    var shell = new fs.Shell();
+    shell.cd('/', function(err) {
+      expect(err).to.not.exist;
+      shell.mkdirp('test', function(err) {
+        expect(err).to.not.exist;
+        fs.exists('/test', function(dir){
+          expect(dir).to.be.true;
+          done();
+        });
+      });
+    });
+  });
+
   it('should succeed on a folder with a nonexistant parent (\'/test/test\')', function(done) {
     var fs = util.fs();
     var shell = new fs.Shell();

tests/spec/shims/fs.spec.js

@@ -0,0 +1,44 @@
+'use strict';
+const expect = require('chai').expect;
+const utils = require('../../lib/test-utils');
+const fs = utils.shimIndexedDB(() => require('../../../shims/fs'));
+
+describe('fs shim', () => {
+  it('should be defined', () => {
+    expect(fs).to.not.be.undefined;
+  });
+
+  it('should be an object', () => {
+    expect(typeof fs).to.equal('object');
+  });
+
+  it('should return a function when accessing fs.writeFile', () => {
+    expect(typeof fs.writeFile).to.equal('function');
+  });
+
+  it('should call callback when calling fs.writeFile', (done) => {
+    fs.writeFile('/test.txt', 'test', function(err) {
+      if(err) throw err;
+
+      done();
+    });
+  });
+
+  it('should return an object when accessing fs.promises', () => {
+    expect(typeof fs.promises).to.equal('object');
+  });
+
+  it('should return a function when accessing fs.promises.writeFile', () => {
+    expect(typeof fs.promises.writeFile).to.equal('function');
+  });
+
+  it('should return a promise which resolves when calling fs.promises.writeFile', (done) => {
+    const writeFilePromise = fs.promises.writeFile('/test2.txt', '');
+    expect(writeFilePromise instanceof Promise).to.equal(true);
+    writeFilePromise.then(() => {
+      done();
+    }).catch((err) => {
+      done(err);
+    });
+  });
+});

tests/spec/shims/path.spec.js

@@ -0,0 +1,14 @@
+'use strict';
+const expect = require('chai').expect;
+const path = require('../../../shims/path');
+const pathActual = require('../../../src/index').path;
+
+describe('path shim', () => {
+  it('should be defined', () => {
+    expect(path).to.not.be.undefined;
+  });
+
+  it('should be re-exposing path', () => {
+    expect(path).to.equal(pathActual);
+  });
+});

tests/spec/time-flags.spec.js

@@ -1,14 +1,16 @@
-var Filer = require('../../src');
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+
+const Filer = require('../../src');
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('node times (atime, mtime, ctime) with mount flags', function() {
 
-  var dirname = '/dir';
-  var filename = '/dir/file';
+  const dirname = '/dir';
+  const filename = '/dir/file';
 
   function memoryFS(flags, callback) {
-    var name = util.uniqueName();
+    const name = util.uniqueName();
     return new Filer.FileSystem({
       name: name,
       flags: flags || [],
@@ -44,7 +46,7 @@ describe('node times (atime, mtime, ctime) with mount flags', function() {
 
   it('should not update ctime when calling fs.rename() with NOCTIME', function(done) {
     memoryFS(['NOCTIME'], function(error, fs) {
-      var newfilename = filename + '1';
+      const newfilename = filename + '1';
 
       createTree(fs, function() {
         stat(fs, filename, function(stats1) {

tests/spec/times.spec.js

@@ -1,15 +1,16 @@
-var util = require('../lib/test-utils.js');
-var expect = require('chai').expect;
+'use strict';
+const util = require('../lib/test-utils.js');
+const expect = require('chai').expect;
 
 describe('node times (atime, mtime, ctimeMs)', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
-  var dirname = '/dir';
-  var filename = '/dir/file';
+  const dirname = '/dir';
+  const filename = '/dir/file';
 
   function createTree(callback) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.mkdir(dirname, function(error) {
       if(error) throw error;
 
@@ -22,7 +23,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   }
 
   function stat(path, callback) {
-    var fs = util.fs();
+    const fs = util.fs();
     fs.stat(path, function(error, stats) {
       if(error) throw error;
 
@@ -31,8 +32,8 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   }
 
   it('should update ctime when calling fs.rename()', function(done) {
-    var fs = util.fs();
-    var newfilename = filename + '1';
+    const fs = util.fs();
+    const newfilename = filename + '1';
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -52,7 +53,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, mtime, atime when calling fs.truncate()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -72,7 +73,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, mtime, atime when calling fs.ftruncate()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -97,7 +98,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.stat()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -115,7 +116,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.fstat()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -138,7 +139,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.lstat()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.link(filename, '/link', function(error) {
@@ -159,7 +160,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.exists()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -181,7 +182,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime when calling fs.link()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -200,7 +201,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.symlink()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -219,7 +220,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.readlink()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.symlink(filename, '/link', function(error) {
@@ -243,7 +244,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime, mtime of parent dir when calling fs.unlink()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(dirname, function(stats1) {
@@ -262,7 +263,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime, mtime of parent dir when calling fs.rmdir()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat('/', function(stats1) {
@@ -286,7 +287,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime, mtime of parent dir when calling fs.mkdir()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat('/', function(stats1) {
@@ -306,7 +307,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.close()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.open(filename, 'w', function(error, fd) {
@@ -329,7 +330,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.open()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -353,8 +354,8 @@ describe('node times (atime, mtime, ctimeMs)', function() {
    */
 
   it('should update atime, ctime, mtime when calling fs.write()', function(done) {
-    var fs = util.fs();
-    var buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
     createTree(function() {
       fs.open('/myfile', 'w', function(error, fd) {
@@ -382,8 +383,8 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.read()', function(done) {
-    var fs = util.fs();
-    var buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    const fs = util.fs();
+    const buffer = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
     createTree(function() {
       fs.open('/myfile', 'w', function(err, fd) {
@@ -400,7 +401,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
               if(error) throw error;
 
               stat('/myfile', function(stats1) {
-                var buffer2 = Buffer.alloc(buffer.length);
+                const buffer2 = Buffer.alloc(buffer.length);
 
                 fs.read(fd, buffer2, 0, buffer2.length, 0, function(err, nbytes) {
                   if(err) throw err;
@@ -426,7 +427,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.readFile()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -446,7 +447,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update atime, ctime, mtime when calling fs.writeFile()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -465,7 +466,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update atime, ctime, mtime when calling fs.appendFile()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -484,7 +485,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime when calling fs.setxattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       stat(filename, function(stats1) {
@@ -503,7 +504,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime when calling fs.fsetxattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.open(filename, 'w', function(error, fd) {
@@ -526,7 +527,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.getxattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.setxattr(filename, 'extra', 'data', function(error) {
@@ -550,7 +551,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should make no change when calling fs.fgetxattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.open(filename, 'w', function(error, fd) {
@@ -578,7 +579,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime when calling fs.removexattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.setxattr(filename, 'extra', 'data', function(error) {
@@ -601,7 +602,7 @@ describe('node times (atime, mtime, ctimeMs)', function() {
   });
 
   it('should update ctime, atime when calling fs.fremovexattr()', function(done) {
-    var fs = util.fs();
+    const fs = util.fs();
 
     createTree(function() {
       fs.open(filename, 'w', function(error, fd) {

tests/spec/webpack-plugin/webpack-plugin.spec.js

@@ -0,0 +1,528 @@
+'use strict';
+const expect = require('chai').expect;
+const utils = require('../../lib/test-utils');
+const FilerWebpackPlugin = require('../../../src/webpack-plugin');
+
+function createNMFResolveCompilerObject(resolveData) {
+
+  const normalModuleFactory_resolve_tap = utils.createMockFn(function (name, callback) {
+    callback(resolveData);
+  });
+
+  const normalModuleFactory = {
+    hooks: {
+      resolve: {
+        tap: normalModuleFactory_resolve_tap
+      }
+    }
+  };
+
+  const normalModuleFactory_tap = utils.createMockFn(function (name, callback) {
+    callback(normalModuleFactory);
+  });
+
+  const compiler = {
+    hooks: {
+      normalModuleFactory: {
+        tap: normalModuleFactory_tap,
+      }
+    }
+  };
+
+  return {
+    compiler,
+    normalModuleFactory_tap,
+    normalModuleFactory_resolve_tap,
+  };
+}
+
+describe('path shim', () => {
+  it('should instantiate the plugin with valid options', () => {
+    // Arrange
+    const options = {
+      filerDir: '/filer',
+      shimsDir: '/shims',
+      fsProviderDir: '/fsProvider',
+      shimFs: false,
+      shimPath: false,
+      fsProvider: 'custom',
+    };
+
+    // Act
+    const plugin = new FilerWebpackPlugin(options);
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal(options.filerDir);
+    expect(plugin.options.shimsDir).to.equal(options.shimsDir);
+    expect(plugin.options.fsProviderDir).to.equal(options.fsProviderDir);
+    expect(plugin.options.shimFs).to.equal(options.shimFs);
+    expect(plugin.options.shimPath).to.equal(options.shimPath);
+    expect(plugin.options.fsProvider).to.equal(options.fsProvider);
+  });
+
+  it('should instantiate the plugin with default options', () => {
+    // Act
+    const plugin = new FilerWebpackPlugin();
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal('/node_modules/filer');
+    expect(plugin.options.shimsDir).to.equal('/node_modules/filer/shims');
+    expect(plugin.options.fsProviderDir).to.equal('/node_modules/filer/shims/providers');
+    expect(plugin.options.shimFs).to.equal(true);
+    expect(plugin.options.shimPath).to.equal(true);
+    expect(plugin.options.fsProvider).to.equal('default');
+  });
+
+  it('should throw if provided invalid options', () => {
+    // Arrange
+    const options = {
+      filerDir: 123,
+      shimsDir: 456,
+      fsProviderDir: 789,
+      shimFs: 'false',
+      shimPath: 'false',
+      fsProvider: false,
+    };
+
+    // Act // Assert
+    expect(() => {
+      new FilerWebpackPlugin(options);
+    }).to.throw();
+  });
+
+  it('should instantiate the plugin with options and the <rootDir> tag should be replaced', () => {
+    // Arrange
+    const options = {
+      filerDir: '<rootDir>/filer',
+      shimsDir: '<rootDir>/shims',
+      fsProviderDir: '<rootDir>/fsProvider',
+    };
+
+    // Act
+    const plugin = new FilerWebpackPlugin(options);
+
+    // Assert
+    expect(plugin.options).to.not.be.undefined;
+
+    expect(plugin.options.filerDir).to.equal(options.filerDir.replace('<rootDir>', ''));
+    expect(plugin.options.shimsDir).to.equal(options.shimsDir.replace('<rootDir>', ''));
+    expect(plugin.options.fsProviderDir).to.equal(options.fsProviderDir.replace('<rootDir>', ''));
+  });
+
+  describe('should instantiate the plugin with valid options and invoke the apply method', () => {
+    it('should ignore an unrelated module', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'aModuleWeDontCareAbout',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/default.js when fsProvider options is default', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'default',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/default.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/indexeddb.js when fsProvider options is indexeddb', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'indexeddb',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/indexeddb.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/memory.js when fsProvider options is memory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'memory',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/memory.js`);
+    });
+
+    it('should resolve fsProvider to <fsProviderDir>/custom.js when fsProvider options is custom', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.fsProviderDir}/custom.js`);
+    });
+
+    it('should throw an error when an invalid options is provided for fsProvider', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'invalid_fs_provider_option',
+      };
+
+      const resolveData = {
+        request: 'fsProvider',
+        context: options.shimsDir,
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+
+      // Act // Assert
+      expect(() => {
+        plugin.apply(compiler);
+      }).to.throw();
+    });
+
+    it('should ignore a request for fs when the context is in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: options.filerDir + '/src',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve a request for fs to the fs shim when the context is not in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: true,
+        shimPath: true,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.shimsDir}/fs.js`);
+    });
+
+    it('should not resolve a request for fs to the fs shim when the context is not in the filer directory but shimFs is false', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'fs',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+
+    it('should resolve a request for path to the path shim when the context is not in the filer directory', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: true,
+        shimPath: true,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'path',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(`${options.shimsDir}/path.js`);
+    });
+
+    it('should not resolve a request for path to the path shim when the context is not in the filer directory but shimPath is false', () => {
+      // Arrange
+      const options = {
+        filerDir: '/filer',
+        shimsDir: '/shims',
+        fsProviderDir: '/fsProvider',
+        shimFs: false,
+        shimPath: false,
+        fsProvider: 'custom',
+      };
+
+      const resolveData = {
+        request: 'path',
+        context: '/some/random/directory',
+      };
+      const resolveDataIn = Object.create(resolveData);
+
+      // Mocks
+      const {
+        compiler,
+        normalModuleFactory_tap,
+        normalModuleFactory_resolve_tap,
+      } = createNMFResolveCompilerObject(resolveDataIn);
+
+      // Act
+      const plugin = new FilerWebpackPlugin(options);
+      plugin.apply(compiler);
+
+      // Assert
+      expect(normalModuleFactory_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(normalModuleFactory_resolve_tap.calls).to.have.length(1);
+      expect(normalModuleFactory_resolve_tap.calls[0].args[0]).to.equal('filer-webpack-plugin');
+
+      expect(resolveDataIn.request).to.equal(resolveData.request);
+    });
+  });
+});

webpack/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  FilerWebpackPlugin: require('../src/webpack-plugin'),
+};