Support (ignore) query params (#1)

Use url.parse() to just pick out the path so we don't need to worry about the actual URL format. Also, add unit tests.

Author: Ben Demboski

index.js

@@ -1,5 +1,4 @@
-const { join } = require('path');
-const fs = require('fs');
+const createHandler = require('./lib/create-handler');
 
 function requiredParam(param, errorMessage) {
   if (!param) {
@@ -35,36 +34,9 @@ module.exports = function protocolServe({
   requiredParam(protocol, 'protocol must be specified, should be electron.protocol');
   requiredParam(app, 'app must be specified, should be electron.app');
 
-  indexPath = indexPath || join(cwd, directoryIndexFile);
-
-  const cache = {};
-  const prefixLength = name.length + 3 + endpoint.length;
-
   app.on('ready', () => {
-    protocol.registerFileProtocol(name, (request, callback) => {
-      // the request url should start with ' ${name}://${endpoint}', remove that
-      const [url/* , hash */] = request.url.substr(prefixLength).split('#');
-      const urlSegments = url.split('/').filter(segment => segment !== '');
-
-      if (urlSegments.length === 0) {
-        urlSegments.push(directoryIndexFile);
-      }
-
-      const filepath = join(cwd, ...urlSegments);
-
-      // redirect empty requests to index.html
-      if (!cache[url]) {
-        try {
-          fs.accessSync(filepath);
-
-          cache[url] = filepath;
-        } catch (err) {
-          //
-        }
-      }
-
-      callback({ path: cache[url] || indexPath });
-    }, error => {
+    const options = { cwd, name, endpoint, directoryIndexFile, indexPath };
+    protocol.registerFileProtocol(name, createHandler(options), error => {
       if (error) {
         console.error('Failed to register protocol');
       }

lib/handler.js

@@ -0,0 +1,51 @@
+const { join } = require('path');
+const fs = require('fs');
+const url = require('url');
+
+module.exports = function createHandler({
+  cwd,
+  name,
+  endpoint,
+  directoryIndexFile,
+  indexPath,
+}) {
+  indexPath = indexPath || join(cwd, directoryIndexFile);
+  const cache = {};
+
+  return (request, callback) => {
+    let {
+      host,
+      pathname,
+    } = url.parse(request.url);
+
+    pathname = pathname || '';
+
+    if (host !== endpoint) {
+      callback({ error: `Unrecognized ${name}:// endpoint: '${host}'` });
+      
+      return;
+    }
+
+    const pathSegments = pathname.split('/').filter(segment => segment !== '');
+
+    if (pathSegments.length === 0) {
+      pathSegments.push(directoryIndexFile);
+    }
+
+    const filepath = join(cwd, ...pathSegments);
+
+    // Basic request caching
+    if (!cache[url]) {
+      try {
+        fs.accessSync(filepath);
+
+        cache[url] = filepath;
+      } catch (err) {
+        //
+      }
+    }
+
+    // redirect unmet requests to directoryIndexFile
+    callback({ path: cache[url] || indexPath });
+  };
+};

package.json

@@ -7,10 +7,16 @@
   "author": "Florian Pichler <pichfl@ylk.gd>",
   "license": "MIT",
   "scripts": {
+    "test": "npm run mocha && npm run lint",
+    "mocha": "mocha ./tests/**/*-test.js",
     "lint": "eslint ."
   },
   "devDependencies": {
-    "eslint": "^3.17.1"
+    "bluebird": "^3.5.0",
+    "chai": "^3.5.0",
+    "eslint": "^3.17.1",
+    "mocha": "^3.2.0",
+    "sinon": "^1.17.7"
   },
   "dependencies": {}
 }

tests/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  root: false,
+  env: {
+    mocha: true,
+  }
+};

tests/unit/handler-test.js

@@ -0,0 +1,133 @@
+const { assert } = require('chai');
+const sinon = require('sinon');
+const Promise = require('bluebird');
+const fs = require('fs');
+const { join, resolve } = require('path');
+const createHandler = require('../../lib/handler');
+
+describe('handler', () => {
+  let sandbox;
+  let mockFiles;
+
+  before(() => {
+    sandbox = sinon.sandbox.create();
+    // Stub accessSync to act like only files in mockFiles exist
+    sandbox.stub(fs, 'accessSync', path => {
+      if (mockFiles.indexOf(path) === -1) {
+        throw new Error('Doesn\'t exist');
+      }
+    });
+  });
+
+  after(() => {
+    sandbox.restore();
+  });
+
+  beforeEach(() => {
+    mockFiles = [];
+  });
+
+  // Create a handler with the specified options and call it with the given URL
+  function handlerExec(url, options = {}) {
+    return new Promise((resolve, reject) => {
+      let handler = createHandler(Object.assign({
+        cwd: '.',
+        name: 'serve',
+        endpoint: 'dist',
+        directoryIndexFile: 'index.html',
+        indexPath: undefined,
+      }, options));
+
+      handler({ url }, ({ path, error }) => {
+        if (path !== undefined) {
+          resolve(path);
+        } else {
+          reject(error);
+        }
+      });
+    });
+  }
+
+  it('works', () => {
+    mockFiles.push('script.js');
+    return handlerExec('serve://dist/script.js').then(path => {
+      assert.equal(path, 'script.js');
+    });
+  });
+
+  it('serves directoryIndexFile from the root', () => {
+    mockFiles.push('foo.html');
+    return handlerExec('serve://dist', {
+      directoryIndexFile: 'foo.html',
+    }).then(path => {
+      assert.equal(path, 'foo.html');
+    });
+  });
+
+  it('serves directoryIndexFile for missing files', () => {
+    mockFiles.push('foo.html');
+    return handlerExec('serve://dist/missing.js', {
+      directoryIndexFile: 'foo.html',
+    }).then(path => {
+      assert.equal(path, 'foo.html');
+    });
+  });
+
+  it('respects relative cwd', () => {
+    mockFiles.push(join('foo', 'bar', 'script.js'));
+    return handlerExec('serve://dist/script.js', {
+      cwd: join('foo', 'bar'),
+    }).then(path => {
+      assert.equal(path, join('foo', 'bar', 'script.js'));
+    });
+  });
+
+  it('respects absolute cwd', () => {
+    mockFiles.push(resolve('foo', 'bar', 'script.js'));
+    return handlerExec('serve://dist/script.js', {
+      cwd: resolve('foo', 'bar'),
+    }).then(path => {
+      assert.equal(path, resolve('foo', 'bar', 'script.js'));
+    });
+  });
+
+  it('respects endpoint', () => {
+    mockFiles.push('script.js');
+    return handlerExec('serve://custom/script.js', {
+      endpoint: 'custom',
+    }).then(path => {
+      assert.equal(path, 'script.js');
+    });
+  });
+
+  it('respects indexPath for missing files', () => {
+    mockFiles.push(join('foo', 'bar.html'));
+    return handlerExec('serve://dist/missing.js', {
+      indexPath: join('foo', 'bar.html'),
+    }).then(path => {
+      assert.equal(path, join('foo', 'bar.html'));
+    });
+  });
+
+  it('ignores hashes', () => {
+    mockFiles.push('script.js');
+    return handlerExec('serve://dist/script.js#hash').then(path => {
+      assert.equal(path, 'script.js');
+    });
+  });
+
+  it('ignores query params', () => {
+    mockFiles.push('script.js');
+    return handlerExec('serve://dist/script.js?query=param').then(path => {
+      assert.equal(path, 'script.js');
+    });
+  });
+
+  it('errors on an unrecognized endpoint', () =>
+    handlerExec('service://notdist/script.js').then(() => {
+      assert.ok(false);
+    }).catch(() => {
+      assert.ok(true);
+    })
+  );
+});