first pass

Author: orthagonal

.travis.yml

@@ -1,4 +1,3 @@
 language: node_js
 node_js:
   - "8"
-  - "6"

index.js

@@ -2,26 +2,22 @@
 const useragent = require('useragent');
 const wreck = require('wreck');
 
-module.exports = (server, options, allDone) => {
+const register = async (server, options) => {
   options = options || {};
   if (!options.method) {
-    return allDone(new Error('hapi-trailing-slash plugin registered without specifiying which method to use'));
+    return Promise.reject(new Error('hapi-trailing-slash plugin registered without specifiying which method to use'));
   }
   options.statusCode = options.statusCode || 301;
 
-  const redirectExists = (redirectPath, callback) => {
+  const redirectExists = (redirectPath) => {
     if (!options.checkIfExists) {
-      return callback(true);
+      return Promise.resolve(true);
     }
-    wreck.request('head', redirectPath, {}, (err, res) => {
-      if (err) {
-        return callback(false);
-      }
-      return callback(res.statusCode < 400);
-    });
+    { res, payload } = wreck.request('head', redirectPath, {});
+    return Promise.resolve(res.statusCode < 400);
   };
 
-  const doRedirect = (path, request, reply) => {
+  const doRedirect = (path, request, h) => {
     const redirectTo = request.url.search ? path + request.url.search : path;
     if (options.verbose) {
       server.log(['hapi-trailing-slash', 'redirect'], {
@@ -34,15 +30,17 @@ module.exports = (server, options, allDone) => {
         to: redirectTo
       });
     }
-    return reply.redirect(redirectTo).code(options.statusCode);
+    return h
+    .redirect(redirectTo)
+    .code(options.statusCode);
   };
 
   // if (options.method === 'append') {
-  server.ext('onPreResponse', (request, reply) => {
+  server.ext('onPreResponse', (request, h) => {
     const statusCode = request.response.output ? request.response.output.statusCode : request.response.statusCode;
     // if the route was already found by hapi then just ignore it:
     if (statusCode !== 404) {
-      return reply.continue();
+      return h.continue;
     }
     const method = request.method.toLowerCase();
     // pick a condition checker based on either 'append' or 'remove' mode:
@@ -51,25 +49,26 @@ module.exports = (server, options, allDone) => {
     // see if we need to do a redirect for either slashed/slashless path:
     if (['get', 'head'].indexOf(method) !== -1 && condition()) {
       if (request.path.indexOf('.') !== -1) {
-        return reply.continue();
+        return h.continue;
       }
       // pick a redirection based on either 'append' or 'remove' mode:
       const redirectPath = options.method === 'append' ? `${request.path}/` : request.path.replace(/\/$/, '');
       return redirectExists(redirectPath, (exists) => {
         if (exists) {
-          doRedirect(redirectPath, request, reply);
+          doRedirect(redirectPath, request, h);
         } else {
-          return reply.continue();
+          return h.continue;
         }
       });
     }
     // otherwise it really is a 404:
-    return reply.continue();
+    return h.continue;
   });
-  allDone();
+  return Promise.resolve();
 };
 
-module.exports.attributes = {
-  name: 'hapi-trailing-slash',
+exports.plugin = {
+  register,
+  once: true,
   pkg: require('./package.json')
 };

package.json

@@ -21,15 +21,14 @@
   },
   "homepage": "https://github.com/firstandthird/hapi-trailing-slash#readme",
   "devDependencies": {
-    "code": "^4.0.0",
+    "code": "^5.1.2",
     "eslint": "^3.9.1",
     "eslint-config-firstandthird": "^3.2.0",
     "eslint-plugin-import": "^2.1.0",
-    "hapi": "^16.1.1",
-    "lab": "^13.0.1"
+    "hapi": "^17.0.1",
+    "lab": "^15.1.2"
   },
   "dependencies": {
-    "useragent": "^2.2.1",
-    "wreck": "^12.0.0"
+    "useragent": "^2.2.1"
   }
 }

test/append.test.js

@@ -8,144 +8,122 @@ const theModule = require('../index.js');
 lab.experiment('hapi-trailing-slash', () => {
   let server;
 
-  lab.beforeEach((done) => {
+  lab.beforeEach(async() => {
     server = new Hapi.Server();
-    server.connection();
-
     server.route([
       {
         method: 'GET',
         path: '/no/slash',
-        handler: (request, reply) => {
-          reply('welcome to the jungle');
+        handler: (request, h) => {
+          return 'welcome to the jungle';
         }
       },
       {
         method: 'GET',
         path: '/has/slash/',
-        handler: (request, reply) => {
-          reply('slither');
+        handler: (request, h) => {
+          return 'slither';
         }
       },
       {
         method: 'GET',
         path: '/has/slash/{band}/',
-        handler: (request, reply) => {
+        handler: (request, h) => {
           if (request.params.band === 'gnr') {
-            reply('sweet child of mine ');
+            return 'sweet child of mine ';
           } else if (request.params.band === 'velvet_revolver') {
-            reply('slither');
+            return 'slither';
           } else {
-            reply('not found');
+            return 'not found';
           }
         }
       }
     ]);
 
-    server.register({
-      register: theModule,
+    const response = await server.register({
+      plugin: theModule,
       options: {
         method: 'append',
         verbose: true
       }
-    }, (err) => {
-      if (err) {
-        throw err;
-      }
-      server.start(done);
     });
+    await server.start();
   });
 
-  lab.afterEach((done) => {
-    server.stop(done);
+  lab.afterEach(async() => {
+    await server.stop();
   });
 
-  lab.test(' "append"  /has/slash/ works normally', (done) => {
-    server.inject({
+  lab.test(' "append"  /has/slash/ works normally', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
-  lab.test(' "append" /has/slash works normally if that route is specified', (done) => {
+  lab.test(' "append" /has/slash works normally if that route is specified', async() => {
     server.route({
       path: '/has/slash',
       method: 'get',
-      handler(request, reply) {
-        return reply('slither');
+      handler(request, h) {
+        return 'slither';
       }
     });
-    server.inject({
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
 
-  lab.test(' "append" GET /has/slash redirects to /has/slash/', (done) => {
-    server.inject({
+  lab.test(' "append" GET /has/slash redirects to /has/slash/', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/');
   });
-  lab.test(' "append" HEAD /has/slash redirects to /has/slash/', (done) => {
-    server.inject({
+  lab.test(' "append" HEAD /has/slash redirects to /has/slash/', async() => {
+    const result = await server.inject({
       method: 'head',
       url: '/has/slash'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/');
   });
-  lab.test(' "append"  /has/slash/ GET works with url params', (done) => {
-    server.inject({
+  lab.test(' "append"  /has/slash/ GET works with url params', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/velvet_revolver/'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(200);
-      Code.expect(result.payload).to.equal('slither');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(200);
+    Code.expect(result.payload).to.equal('slither');
   });
 
-  lab.test(' "append" /has/slash GET redirects with url params ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash GET redirects with url params ', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/has/slash/velvet_revolver?temp=hi'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(301);
-      Code.expect(result.headers.location).to.equal('/has/slash/velvet_revolver/?temp=hi');
-      done();
     });
+    Code.expect(result.statusCode).to.equal(301);
+    Code.expect(result.headers.location).to.equal('/has/slash/velvet_revolver/?temp=hi');
   });
-  lab.test(' "append" /has/slash POST redirect is ignored ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash POST redirect is ignored ', async() => {
+    const result = await server.inject({
       method: 'post',
       url: '/has/slash/velvet_revolver?temp=hi'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(404);
-      done();
     });
+    Code.expect(result.statusCode).to.equal(404);
   });
 
-  lab.test(' "append" /has/slash.png redirect is ignored ', (done) => {
-    server.inject({
+  lab.test(' "append" /has/slash.png redirect is ignored ', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/images/logo.png'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(404);
-      done();
     });
+    Code.expect(result.statusCode).to.equal(404);
   });
 });

test/checkIfExists.test.js

@@ -8,59 +8,51 @@ const theModule = require('../index.js');
 lab.experiment('hapi-trailing-slash checkIfExists', () => {
   let server;
 
-  lab.beforeEach((done) => {
+  lab.beforeEach(async() => {
     server = new Hapi.Server();
-    server.connection();
 
     server.route([
       {
         method: 'GET',
         path: '/no/slash',
-        handler: (request, reply) => {
-          reply('chinese democracy');
+        handler: (request, h) => {
+          return 'chinese democracy';
         }
       },
       {
         method: 'GET',
         path: '/has/slash/',
-        handler: (request, reply) => {
-          reply('slither').code(301);
+        handler: (request, h) => {
+          return h.redirect('slither');
         }
       },
     ]);
 
-    server.register({
-      register: theModule,
+    await server.register({
+      plugin: theModule,
       options: {
         checkIfExists: true,
         method: 'remove',
         verbose: true
       }
-    }, (err) => {
-      if (err) {
-        throw err;
-      }
-      server.start(done);
     });
+    await server.start(done);
   });
 
-  lab.afterEach((done) => {
-    server.stop(done);
+  lab.afterEach(async() => {
+    await server.stop();
   });
 
-  lab.test(' checkIfExists will do a HEAD check that the forward exists', (done) => {
-    server.inject({
+  lab.test(' checkIfExists will do a HEAD check that the forward exists', async() => {
+    const result = await server.inject({
       method: 'get',
       url: '/no/slash/'
-    }, (result) => {
-      Code.expect(result.statusCode).to.equal(404);
-      server.inject({
-        method: 'get',
-        url: '/has/slash/'
-      }, (result2) => {
-        Code.expect(result2.statusCode).to.equal(301);
-        done();
-      });
     });
+    Code.expect(result.statusCode).to.equal(404);
+    const result2 = await server.inject({
+      method: 'get',
+      url: '/has/slash/'
+    });
+    Code.expect(result2.statusCode).to.equal(301);
   });
 });