diff --git a/.travis.yml b/.travis.yml
index a0eed05..2208aad 100755
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,19 +1,14 @@
 language: node_js
 
 node_js:
-  - "4"
-  - "6"
-  - "7"
+  - "8"
   - "node"
 
 sudo: false
 
 env:
-    - HAPI_VERSION="13"
-    - HAPI_VERSION="14"
-    - HAPI_VERSION="15"
+    - HAPI_VERSION="17"
 
 install:
     - npm install
     - npm install hapi@$HAPI_VERSION
-
diff --git a/LICENSE b/LICENSE
index 368907a..0d5c776 100755
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2012-2016, Project contributors.
+Copyright (c) 2012-2017, Project contributors.
 Copyright (c) 2012-2015, Walmart.
 All rights reserved.
 
diff --git a/examples/mustache/partials.js b/examples/mustache/partials.js
old mode 100644
new mode 100755
index f9b7106..d175fa5
--- a/examples/mustache/partials.js
+++ b/examples/mustache/partials.js
@@ -27,7 +27,7 @@ internals.main = function () {
     server.register(Vision, (err) => {
 
         if (err) {
-            throw error;
+            throw err;
         }
 
         const partials = {};
diff --git a/lib/index.js b/lib/index.js
index 1df9e70..9415e2a 100755
--- a/lib/index.js
+++ b/lib/index.js
@@ -1,11 +1,13 @@
 'use strict';
+
 // Load modules
 
 const Hoek = require('hoek');
 const Joi = require('joi');
-const Manager = require('./manager');
 // Additional helper modules required in constructor
 
+const Manager = require('./manager');
+
 
 // Declare internals
 
@@ -22,7 +24,7 @@ internals.schema = Joi.alternatives([
 ]);
 
 
-exports.register = function (server, pluginOptions, next) {
+exports.register = function (server, pluginOptions) {
 
     server.decorate('server', 'views', function (options) {
 
@@ -47,35 +49,27 @@ exports.register = function (server, pluginOptions, next) {
 
     server.handler('view', internals.handler);
 
-    server.decorate('reply', 'view', function (template, context, options) {
+    server.decorate('toolkit', 'view', function (template, context, options) {
 
         const realm = (this.realm.plugins.vision || this.request.server.realm.plugins.vision || {});
         Hoek.assert(realm.manager, 'Cannot render view without a views manager configured');
-        return this.response(realm.manager._response(template, context, options, this.request));
+        return this.wrap(realm.manager._response(template, context, options, this.request));
     });
-
-    return next();
 };
 
 exports.register.attributes = {
-    connections: false,
     once: true,
     pkg: require('../package.json')
 };
 
 
-internals.render = function (template, context, options, callback) {
-
-    if (!callback && typeof options === 'function') {
-        callback = options;
-        options = {};
-    }
+internals.render = async function (template, context, options = {}) {
 
     const isServer = (typeof this.route === 'function');
     const server = (isServer ? this : this.server);
-    const vision = ((!isServer ? this.route.realm.plugins.vision : null) || server.realm.plugins.vision || server.root.realm.plugins.vision || {});
+    const vision = ((!isServer ? this.route.realm.plugins.vision : null) || server.realm.plugins.vision || server.root.plugins.vision || {});
     Hoek.assert(vision.manager, 'Missing views manager');
-    return vision.manager.render(template, context, options, callback);
+    return await vision.manager.render(template, context, options);
 };
 
 
@@ -93,7 +87,7 @@ internals.handler = function (route, options) {
         options: options.options
     };
 
-    return function (request, reply) {
+    return function (request, responder) {
 
         const context = {
             params: request.params,
@@ -110,6 +104,6 @@ internals.handler = function (route, options) {
             }
         }
 
-        reply.view(settings.template, context, settings.options);
+        return responder.view(settings.template, context, settings.options);
     };
 };
diff --git a/lib/manager.js b/lib/manager.js
index a3400bb..c3e677f 100755
--- a/lib/manager.js
+++ b/lib/manager.js
@@ -3,6 +3,7 @@
 
 const Fs = require('fs');
 const Path = require('path');
+
 const Boom = require('boom');
 const Hoek = require('hoek');
 const Joi = require('joi');
@@ -454,8 +455,7 @@ internals.Manager.prototype._path = function (template, settings, isLayout, next
 
             return nextFile();
         });
-    },
-    () => {
+    }, () => {
 
         return next(Boom.badImplementation('View file not found: `' + template + '`. Locations searched: [' + paths.join(',') + ']'));
     });
@@ -570,43 +570,51 @@ internals.Manager.prototype._response = function (template, context, options, re
 };
 
 
-internals.marshal = function (response, callback) {
+internals.marshal = function (response) {
 
     const manager = response.source.manager;
 
-    manager._render(response.source.compiled, response.source.context, response.request, (err, rendered) => {
+    return new Promise((resolve, reject) => {
 
-        if (err) {
-            return callback(err);
-        }
+        manager._render(response.source.compiled, response.source.context, response.request, (err, rendered) => {
+
+            if (err) {
+                return reject(err);
+            }
 
-        const config = response.source.compiled.settings;
+            const config = response.source.compiled.settings;
 
-        if (!response.headers['content-type']) {
-            response.type(config.contentType);
-        }
+            if (!response.headers['content-type']) {
+                response.type(config.contentType);
+            }
 
-        response.encoding(config.encoding);
+            response.encoding(config.encoding);
 
-        return callback(null, rendered);
+            return resolve(rendered);
+        });
     });
 };
 
-internals.prepare = function (response, callback) {
+
+internals.prepare = function (response) {
 
     const manager = response.source.manager;
 
-    manager._prepare(response.source.template, response.source.options, (err, compiled) => {
+    return new Promise((resolve, reject) => {
 
-        if (err) {
-            return callback(err);
-        }
+        manager._prepare(response.source.template, response.source.options, (err, compiled) => {
 
-        response.source.compiled = compiled;
-        return callback(response);
+            if (err) {
+                return reject(err);
+            }
+
+            response.source.compiled = compiled;
+            return resolve(response);
+        });
     });
 };
 
+
 internals._wrapMethod = (bind, method, args) => {
 
     return new Promise((resolve, reject) => {
diff --git a/package.json b/package.json
index 304cfe3..96dd1f8 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "vision",
   "description": "Templates rendering plugin support for hapi.js",
-  "version": "4.1.1",
+  "version": "5.0.0-rc4",
   "repository": "git://github.com/hapijs/vision",
   "main": "lib/index.js",
   "keywords": [
@@ -11,24 +11,27 @@
     "hapi"
   ],
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=8.0.0"
   },
   "dependencies": {
-    "boom": "4.x.x",
-    "hoek": "4.x.x",
+    "boom": "6.x.x",
+    "hoek": "5.x.x",
     "items": "2.x.x",
-    "joi": "10.x.x"
+    "joi": "11.x.x"
+  },
+  "peerDependencies": {
+    "hapi": ">=17.0.0-0"
   },
   "devDependencies": {
     "babel-core": "6.x.x",
     "babel-plugin-transform-react-jsx": "6.x.x",
-    "code": "4.x.x",
+    "code": "5.x.x",
     "ejs": "2.x.x",
     "handlebars": "4.x.x",
-    "hapi": "15.x.x",
+    "hapi": "^17.0.0-rc4",
     "hapi-react-views": "6.x.x",
     "pug": ">=2.0.0-beta6",
-    "lab": "11.x.x",
+    "lab": "14.x.x",
     "marko": "3.x.x",
     "mustache": "2.x.x",
     "nunjucks": "2.x.0",
diff --git a/test/index.js b/test/index.js
index b916c65..fbd7e11 100755
--- a/test/index.js
+++ b/test/index.js
@@ -1,11 +1,12 @@
 'use strict';
+
 // Load modules
 
 const Path = require('path');
+
 const Code = require('code');
 const Handlebars = require('handlebars');
 const Hapi = require('hapi');
-const Hoek = require('hoek');
 const Pug = require('pug');
 const Lab = require('lab');
 const Vision = require('..');
@@ -26,50 +27,38 @@ const expect = Code.expect;
 
 describe('handler()', () => {
 
-    it('handles routes to views', (done) => {
+    it('handles routes to views', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates'
         });
 
         server.route({ method: 'GET', path: '/{param}', handler: { view: 'valid/handler' } });
-        server.inject({
-            method: 'GET',
-            url: '/hello'
-        }, (res) => {
-
-            expect(res.result).to.contain('hello');
-            done();
-        });
+        const res = await server.inject({ method: 'GET', url: '/hello' });
+        expect(res.result).to.contain('hello');
     });
 
-    it('handles custom context', (done) => {
+    it('handles custom context', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { pug: Pug },
             path: __dirname + '/templates'
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/index', context: { message: 'heyloo' } } } });
-        server.inject('/', (res) => {
-
-            expect(res.result).to.contain('heyloo');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.contain('heyloo');
     });
 
-    it('handles custom options', (done) => {
+    it('handles custom options', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates',
@@ -77,23 +66,19 @@ describe('handler()', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/options', options: { layout: 'elsewhere' } } } });
-        server.inject('/', (res) => {
-
-            expect(res.result).to.contain('+hello');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.contain('+hello');
     });
 
-    it('includes prerequisites in the default view context', (done) => {
+    it('includes prerequisites in the default view context', async () => {
 
         const pre = function (request, reply) {
 
-            reply('PreHello');
+            return 'PreHello';
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates'
@@ -112,56 +97,44 @@ describe('handler()', () => {
             }
         });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.contain('PreHello');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.contain('PreHello');
     });
 
-    it('handles both custom and default contexts', (done) => {
+    it('handles both custom and default contexts', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates'
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext', context: { message: 'heyloo' } } } });
-        server.inject('/?test=yes', (res) => {
-
-            expect(res.result).to.contain('heyloo');
-            expect(res.result).to.contain('yes');
-            done();
-        });
+        const res = await server.inject('/?test=yes');
+        expect(res.result).to.contain('heyloo');
+        expect(res.result).to.contain('yes');
     });
 
-    it('overrides default contexts when provided with context of same name', (done) => {
+    it('overrides default contexts when provided with context of same name', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates'
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext', context: { message: 'heyloo', query: { test: 'no' } } } } });
-        server.inject('/?test=yes', (res) => {
-
-            expect(res.result).to.contain('heyloo');
-            expect(res.result).to.contain('no');
-            done();
-        });
+        const res = await server.inject('/?test=yes');
+        expect(res.result).to.contain('heyloo');
+        expect(res.result).to.contain('no');
     });
 
-    it('handles a global context object', (done) => {
+    it('handles a global context object', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates',
@@ -171,19 +144,15 @@ describe('handler()', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext' } } });
-        server.inject('/', (res) => {
-
-            expect(res.result).to.contain('<h1></h1>');
-            expect(res.result).to.contain('<h1>default message</h1>');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.contain('<h1></h1>');
+        expect(res.result).to.contain('<h1>default message</h1>');
     });
 
-    it('passes the request to a global context function', (done) => {
+    it('passes the request to a global context function', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates',
@@ -197,19 +166,15 @@ describe('handler()', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext' } } });
-        server.inject('/', (res) => {
-
-            expect(res.result).to.contain('<h1></h1>');
-            expect(res.result).to.contain('<h1>/</h1>');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.contain('<h1></h1>');
+        expect(res.result).to.contain('<h1>/</h1>');
     });
 
-    it('overrides the global context with the default handler context', (done) => {
+    it('overrides the global context with the default handler context', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates',
@@ -223,19 +188,15 @@ describe('handler()', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext' } } });
-        server.inject('/?test=yes', (res) => {
-
-            expect(res.result).to.contain('<h1>yes</h1>');
-            expect(res.result).to.contain('<h1>default message</h1>');
-            done();
-        });
+        const res = await server.inject('/?test=yes');
+        expect(res.result).to.contain('<h1>yes</h1>');
+        expect(res.result).to.contain('<h1>default message</h1>');
     });
 
-    it('overrides the global and default contexts with a custom handler context', (done) => {
+    it('overrides the global and default contexts with a custom handler context', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates',
@@ -250,19 +211,15 @@ describe('handler()', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/testContext', context: { message: 'override', query: { test: 'no' } } } } });
-        server.inject('/?test=yes', (res) => {
-
-            expect(res.result).to.contain('<h1>no</h1>');
-            expect(res.result).to.contain('<h1>override</h1>');
-            done();
-        });
+        const res = await server.inject('/?test=yes');
+        expect(res.result).to.contain('<h1>no</h1>');
+        expect(res.result).to.contain('<h1>override</h1>');
     });
 
-    it('throws on missing views', (done) => {
+    it('throws on missing views', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.register(Vision, Hoek.ignore);
-        server.connection();
+        await server.register(Vision);
         server.route({
             path: '/',
             method: 'GET',
@@ -272,79 +229,51 @@ describe('handler()', () => {
             }
         });
 
-        server.inject('/', (res) => {
-
-            expect(res.statusCode).to.equal(500);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.statusCode).to.equal(500);
     });
 });
 
 describe('render()', () => {
 
-    it('renders view (root)', (done) => {
+    it('renders view (root)', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         server.views({
             engines: { html: Handlebars },
             path: __dirname + '/templates/valid'
         });
 
-        server.render('test', { title: 'test', message: 'Hapi' }, (err, rendered, config) => {
-
-            expect(err).not.to.exist();
-            expect(rendered).to.exist();
-            expect(rendered).to.contain('Hapi');
-            done();
-        });
+        const rendered = await server.render('test', { title: 'test', message: 'Hapi' });
+        expect(rendered).to.contain('Hapi');
     });
 
-    it('renders view (root with options)', (done) => {
+    it('renders view (root with options)', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         server.views({
             engines: { html: Handlebars }
         });
 
-        server.render('test', { title: 'test', message: 'Hapi' }, { path: Path.join(__dirname, '/templates/valid') }, (err, rendered, config) => {
-
-            expect(err).not.to.exist();
-            expect(rendered).to.exist();
-            expect(rendered).to.contain('Hapi');
-            done();
-        });
+        const rendered = await server.render('test', { title: 'test', message: 'Hapi' }, { path: Path.join(__dirname, '/templates/valid') });
+        expect(rendered).to.contain('Hapi');
     });
 
-    it('renders view (plugin)', (done) => {
+    it('renders view (plugin)', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.views({
                 engines: { 'html': Handlebars },
                 relativeTo: Path.join(__dirname, '/templates/plugin')
             });
 
-            server.render('test', { message: 'steve' }, (err, rendered, config) => {
-
-                expect(err).not.to.exist();
-
-                server.route([
-                    {
-                        path: '/view', method: 'GET', handler: function (request, reply) {
-
-                            return reply(rendered);
-                        }
-                    }
-                ]);
-
-                return next();
-            });
+            const rendered = await server.render('test', { message: 'steve' });
+            server.route({ path: '/view', method: 'GET', handler: () => rendered });
         };
 
         test.attributes = {
@@ -352,39 +281,19 @@ describe('render()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.register(test, (err) => {
+        await server.register(Vision);
 
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
-
-                expect(res.result).to.equal('<h1>steve</h1>');
-                done();
-            });
-        });
+        await server.register(test);
+        const res = await server.inject('/view');
+        expect(res.result).to.equal('<h1>steve</h1>');
     });
 
-    it('renders view (plugin without views)', (done) => {
-
-        const test = function (server, options, next) {
-
-            server.render('test', { message: 'steve' }, (err, rendered, config) => {
-
-                expect(err).not.to.exist();
-
-                server.route([
-                    {
-                        path: '/view', method: 'GET', handler: function (request, reply) {
+    it('renders view (plugin without views)', async () => {
 
-                            return reply(rendered);
-                        }
-                    }
-                ]);
+        const test = async function (server, options) {
 
-                return next();
-            });
+            const rendered = await server.render('test', { message: 'steve' });
+            server.route({ path: '/view', method: 'GET', handler: () => rendered });
         };
 
         test.attributes = {
@@ -392,48 +301,28 @@ describe('render()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         server.views({
             engines: { 'html': Handlebars },
             relativeTo: Path.join(__dirname, '/templates/plugin')
         });
 
-        server.register(test, (err) => {
-
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
-
-                expect(res.result).to.equal('<h1>steve</h1>');
-                done();
-            });
-        });
+        await server.register(test);
+        const res = await server.inject('/view');
+        expect(res.result).to.equal('<h1>steve</h1>');
     });
 
-    it('renders view (plugin with options)', (done) => {
+    it('renders view (plugin with options)', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.views({
                 engines: { 'html': Handlebars }
             });
 
-            server.render('test', { message: 'steve' }, { relativeTo: Path.join(__dirname, '/templates/plugin') }, (err, rendered, config) => {
-
-                expect(err).not.to.exist();
-
-                server.route([
-                    {
-                        path: '/view', method: 'GET', handler: function (request, reply) {
-
-                            return reply(rendered);
-                        }
-                    }
-                ]);
-
-                return next();
-            });
+            const rendered = await server.render('test', { message: 'steve' }, { relativeTo: Path.join(__dirname, '/templates/plugin') });
+            server.route({ path: '/view', method: 'GET', handler: () => rendered });
         };
 
         test.attributes = {
@@ -441,34 +330,24 @@ describe('render()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.register(test, (err) => {
+        await server.register(Vision);
 
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
+        await server.register(test);
+        const res = await server.inject('/view');
 
-                expect(res.result).to.equal('<h1>steve</h1>');
-                done();
-            });
-        });
+        expect(res.result).to.equal('<h1>steve</h1>');
     });
 
-    it('throws on missing views', (done) => {
+    it('rejects on missing views', async () => {
 
         const server = new Hapi.Server();
-        server.register(Vision, Hoek.ignore);
-        expect(() => {
-
-            server.render('test');
-        }).to.throw('Missing views manager');
-        done();
+        await server.register(Vision);
+        await expect(server.render('test')).to.reject('Missing views manager');
     });
 
-    it('renders view (plugin request)', (done) => {
+    it('renders view (plugin request)', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.views({
                 engines: { 'html': Handlebars },
@@ -478,17 +357,8 @@ describe('render()', () => {
             server.route({
                 method: 'GET',
                 path: '/view',
-                handler: function (request, reply) {
-
-                    request.render('test', { message: 'steve' }, (err, rendered, config) => {
-
-                        expect(err).not.to.exist();
-                        return reply(rendered);
-                    });
-                }
+                handler: (request) => request.render('test', { message: 'steve' })
             });
-
-            return next();
         };
 
         test.attributes = {
@@ -496,25 +366,16 @@ describe('render()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.register(test, (err) => {
-
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
-
-                expect(res.result).to.equal('<h1>steve</h1>');
-                done();
-            });
-        });
+        await server.register(Vision);
+        await server.register(test);
+        const res = await server.inject('/view');
+        expect(res.result).to.equal('<h1>steve</h1>');
     });
 
-    it('does not pass the request to the global context function (server)', (done) => {
+    it('does not pass the request to the global context function (server)', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates/valid',
@@ -527,19 +388,14 @@ describe('render()', () => {
             }
         });
 
-        server.render('testContext', null, null, (err, result) => {
-
-            expect(err).not.to.exist();
-            expect(result).to.contain('<h1>default</h1>');
-            done();
-        });
+        const rendered = await server.render('testContext', null, null);
+        expect(rendered).to.contain('<h1>default</h1>');
     });
 
-    it('does not pass the request to the global context function (request)', (done) => {
+    it('does not pass the request to the global context function (request)', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates/valid',
@@ -552,110 +408,17 @@ describe('render()', () => {
             }
         });
 
-        const handler = (request, reply) => {
-
-            request.render('testContext', null, null, (err, rendered) => {
-
-                expect(err).not.to.exist();
-                reply(rendered);
-            });
-        };
-
-        server.route({ method: 'GET', path: '/', handler });
-        server.inject({ method: 'GET', url: '/' }, (response) => {
-
-            expect(response.result).to.contain('<h1>default</h1>');
-            done();
-        });
-    });
-
-    it('returns a promise when no options or callback given (server)', () => {
-
-        const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-        server.views({
-            engines: { html: Handlebars },
-            path: __dirname + '/templates/valid'
-        });
-
-        return server.render('test', { message: 'Hello!' })
-        .then((content) => expect(content).to.contain('<h1>Hello!</h1>'));
-    });
-
-    it('returns a promise when no callback given (server)', () => {
-
-        const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.views({
-            engines: { html: Handlebars },
-            path: __dirname + '/templates/valid'
-        });
-
-        return server.render('test', { message: 'Hello!' }, {})
-        .then((content) => expect(content).to.contain('<h1>Hello!</h1>'));
-    });
-
-    it('returns a promise when no options or callback given (request)', (done) => {
-
-        const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.views({
-            engines: { html: Handlebars },
-            path: __dirname + '/templates/valid'
-        });
-
-        const handler = (request, reply) => {
-
-            const promise = request.render('test', { message: 'Hello!' });
-            expect(promise).to.be.an.instanceof(Promise);
-            reply(promise);
-        };
-
-        server.route({ method: 'GET', path: '/', handler });
-        server.inject({ method: 'GET', url: '/' }, (response) => {
-
-            expect(response.result).to.contain('<h1>Hello!</h1>');
-            done();
-        });
-    });
-
-    it('returns a promise when no callback given (request)', (done) => {
-
-        const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.views({
-            engines: { html: Handlebars },
-            path: __dirname + '/templates/valid'
-        });
-
-        const handler = (request, reply) => {
-
-            const promise = request.render('test', { message: 'Hello!' }, {});
-            expect(promise).to.be.an.instanceof(Promise);
-            reply(promise);
-        };
-
-        server.route({ method: 'GET', path: '/', handler });
-        server.inject({ method: 'GET', url: '/' }, (response) => {
-
-            expect(response.result).to.contain('<h1>Hello!</h1>');
-            done();
-        });
+        server.route({ method: 'GET', path: '/', handler: (request) => request.render('testContext', null, null) });
+        const res = await server.inject({ method: 'GET', url: '/' });
+        expect(res.result).to.contain('<h1>default</h1>');
     });
 });
 
 describe('views()', () => {
 
-    it('requires plugin with views', (done) => {
+    it('requires plugin with views', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.path(__dirname);
 
@@ -665,29 +428,20 @@ describe('views()', () => {
             };
 
             server.views(views);
+
             if (Object.keys(views).length !== 2) {
-                return next(new Error('plugin.view() modified options'));
+                throw new Error('plugin.view() modified options');
             }
 
-            server.route([
-                {
-                    path: '/view', method: 'GET', handler: function (request, reply) {
-
-                        return reply.view('test', { message: options.message });
-                    }
-                }
-            ]);
-
+            server.route({ path: '/view', method: 'GET', handler: (request, reply) => reply.view('test', { message: options.message }) });
             server.ext('onRequest', (request, reply) => {
 
                 if (request.path === '/ext') {
-                    return reply.view('test', { message: 'grabbed' });
+                    return reply.view('test', { message: 'grabbed' }).takeover();
                 }
 
-                return reply.continue();
+                return reply.continue;
             });
-
-            return next();
         };
 
         test.attributes = {
@@ -695,44 +449,26 @@ describe('views()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
-
-        server.register({ register: test, options: { message: 'viewing it' } }, (err) => {
-
-            expect(err).to.not.exist();
-            server.inject('/view', (viewResponse) => {
-
-                expect(viewResponse.result).to.equal('<h1>viewing it</h1>');
+        await server.register(Vision);
+        await server.register({ register: test, options: { message: 'viewing it' } });
 
-                server.inject('/ext', (extResponse) => {
+        const res1 = await server.inject('/view');
+        expect(res1.result).to.equal('<h1>viewing it</h1>');
 
-                    expect(extResponse.result).to.equal('<h1>grabbed</h1>');
-                    done();
-                });
-            });
-        });
+        const res2 = await server.inject('/ext');
+        expect(res2.result).to.equal('<h1>grabbed</h1>');
     });
 
-    it('requires plugin with views with specific relativeTo', (done) => {
+    it('requires plugin with views with specific relativeTo', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.views({
                 engines: { 'html': Handlebars },
                 relativeTo: Path.join(__dirname, '/templates/plugin')
             });
 
-            server.route([
-                {
-                    path: '/view', method: 'GET', handler: function (request, reply) {
-
-                        return reply.view('test', { message: 'steve' });
-                    }
-                }
-            ]);
-
-            return next();
+            server.route({ path: '/view', method: 'GET', handler: (request, reply) => reply.view('test', { message: 'steve' }) });
         };
 
         test.attributes = {
@@ -740,34 +476,22 @@ describe('views()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
+        await server.register(test);
 
-        server.register(test, (err) => {
-
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
-
-                expect(res.result).to.equal('<h1>steve</h1>');
-                done();
-            });
-        });
+        const res = await server.inject('/view');
+        expect(res.result).to.equal('<h1>steve</h1>');
     });
 
-    it('defaults to server views', (done) => {
+    it('defaults to server views', async () => {
 
-        const test = function (server, options, next) {
+        const test = async function (server, options) {
 
             server.route({
                 path: '/view',
                 method: 'GET',
-                handler: function (request, reply) {
-
-                    return reply.view('test', { message: options.message });
-                }
+                handler: (request, reply) => reply.view('test', { message: options.message })
             });
-
-            return next();
         };
 
         test.attributes = {
@@ -775,8 +499,7 @@ describe('views()', () => {
         };
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         server.path(__dirname);
 
@@ -787,33 +510,26 @@ describe('views()', () => {
 
         server.views(views);
 
-        server.register({ register: test, options: { message: 'viewing it' } }, (err) => {
-
-            expect(err).to.not.exist();
-            server.inject('/view', (res) => {
-
-                expect(res.result).to.equal('<h1>viewing it</h1>');
-                done();
-            });
-        });
+        await server.register({ register: test, options: { message: 'viewing it' } });
+        const res = await server.inject('/view');
+        expect(res.result).to.equal('<h1>viewing it</h1>');
     });
 
-    it('throws on multiple views', (done) => {
+    it('throws on multiple views', async () => {
 
         const server = new Hapi.Server();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({ engines: { 'html': Handlebars } });
         expect(() => {
 
             server.views({ engines: { 'html': Handlebars } });
         }).to.throw('Cannot set views manager more than once');
-        done();
     });
 
-    it('can register helpers via the view manager', (done) => {
+    it('can register helpers via the view manager', async () => {
 
         const server = new Hapi.Server();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         const manager = server.views({
             engines: { 'html': Handlebars.create() },
@@ -824,18 +540,14 @@ describe('views()', () => {
         manager.registerHelper('long', (string) => string);
         manager.registerHelper('uppercase', (string) => string);
 
-        server.render('testHelpers', { something: 'uppercase' }, (err, result) => {
-
-            expect(err).not.to.exist();
-            expect(result).to.equal('<p>This is all uppercase and this is how we like it!</p>');
-            done();
-        });
+        const rendered = await server.render('testHelpers', { something: 'uppercase' });
+        expect(rendered).to.equal('<p>This is all uppercase and this is how we like it!</p>');
     });
 
-    it('can render templates via the view manager', (done) => {
+    it('can render templates via the view manager', async () => {
 
         const server = new Hapi.Server();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
 
         const manager = server.views({
             engines: { 'html': Handlebars },
@@ -843,62 +555,29 @@ describe('views()', () => {
             path: 'valid'
         });
 
-        manager.render('test', { message: 'Hello!' }, null, (err, result) => {
-
-            expect(err).not.to.exist();
-            expect(result).to.contain('<h1>Hello!</h1>');
-            done();
-        });
+        const rendered = await manager.render('test', { message: 'Hello!' }, null);
+        expect(rendered).to.contain('<h1>Hello!</h1>');
     });
 });
 
 describe('Plugin', () => {
 
-    it('can be registered before connections', (done) => {
-
-        const plugin = function (server, options, next) {
-
-            server.dependency('vision');
-            server.connection();
-            next();
-        };
-
-        plugin.attributes = {
-            connections: false,
-            name: 'test'
-        };
-
-        const server = new Hapi.Server();
-        server.register([Vision, plugin], Hoek.ignore);
-
-        expect(server.views).to.be.a.function();
-        server.initialize((err) => {
-
-            expect(err).to.not.exist();
-            server.stop(done);
-        });
-    });
-
-    it('only registers once', (done) => {
+    it('only registers once', async () => {
 
-        const one = function (server, options, next) {
+        const one = function (server, options) {
 
-            server.register(Vision, next);
+            return server.register(Vision);
         };
 
-        const two = function (server, options, next) {
+        const two = function (server, options) {
 
-            server.register(Vision, next);
+            return server.register(Vision);
         };
 
         one.attributes = { name: 'one' };
         two.attributes = { name: 'two' };
 
         const server = new Hapi.Server();
-        server.register([one, two], (err) => {
-
-            expect(err).to.not.exist();
-            done();
-        });
+        await server.register([one, two]);
     });
 });
diff --git a/test/manager.js b/test/manager.js
index fc0e3c4..cb7f9c1 100755
--- a/test/manager.js
+++ b/test/manager.js
@@ -2,16 +2,17 @@
 // Load modules
 
 const Fs = require('fs');
+const Util = require('util');
+
 const Code = require('code');
 const Handlebars = require('handlebars');
 const Hapi = require('hapi');
-const Hoek = require('hoek');
 const Pug = require('pug');
 const Lab = require('lab');
 const Vision = require('..');
-const Manager = require('../lib/manager');
 const Mustache = require('mustache');
-const Util = require('util');
+
+const Manager = require('../lib/manager');
 
 
 // Declare internals
@@ -29,11 +30,10 @@ const expect = Code.expect;
 
 describe('Manager', () => {
 
-    it('renders handlebars template', (done) => {
+    it('renders handlebars template', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await await server.register(Vision);
         server.views({
             engines: {
                 html: {
@@ -45,15 +45,12 @@ describe('Manager', () => {
 
         server.route({ method: 'GET', path: '/handlebars', handler: { view: { template: 'test.html', context: { message: 'Hello World!' } } } });
 
-        server.inject('/handlebars', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/handlebars');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(200);
     });
 
-    it('shallow copies global context', (done) => {
+    it('shallow copies global context', async () => {
 
         const options = {
             engines: {
@@ -68,16 +65,13 @@ describe('Manager', () => {
         };
 
         const manager = new Manager(options);
-
         expect(manager._context).to.equal(options.context);
-        done();
     });
 
-    it('sets content type', (done) => {
+    it('sets content type', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await await server.register(Vision);
         server.views({
             engines: {
                 html: {
@@ -89,20 +83,16 @@ describe('Manager', () => {
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello World!' } } } });
-        server.inject('/', (res) => {
-
-            expect(res.headers['content-type']).to.equal('something/else');
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.headers['content-type']).to.equal('something/else');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(200);
     });
 
-    it('errors on invalid template path', (done) => {
+    it('errors on invalid template path', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/invalid'
@@ -111,18 +101,14 @@ describe('Manager', () => {
         // Rendering errors are not available to extensions.
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello, World!' } } } });
-        server.inject('/', (res) => {
-
-            expect(res.statusCode).to.equal(500);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.statusCode).to.equal(500);
     });
 
-    it('returns a compiled Handlebars template reply', (done) => {
+    it('returns a compiled Handlebars template reply', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -130,20 +116,16 @@ describe('Manager', () => {
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello, World!' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.result).to.have.string('Hello, World!');
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.result).to.have.string('Hello, World!');
+        expect(res.statusCode).to.equal(200);
     });
 
-    it('errors absolute path given and allowAbsolutePath is false (by default)', (done) => {
+    it('errors absolute path given and allowAbsolutePath is false (by default)', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -152,32 +134,28 @@ describe('Manager', () => {
         // Compilation errors sould be available for extensions.
 
         let error = null;
-        server.ext('onPostHandler', (request, reply) => {
+        server.ext('onPreResponse', (request, reply) => {
 
             const response = request.response;
             if (response.isBoom) {
                 error = response;
             }
 
-            reply.continue();
+            return reply.continue;
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: __dirname + '/templates/valid/test', context: { message: 'Hello, World!' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(500);
-            expect(error).to.be.an.instanceof(Error);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(500);
+        expect(error).to.be.an.instanceof(Error);
     });
 
-    it('errors if path given includes ../ and allowInsecureAccess is false (by default)', (done) => {
+    it('errors if path given includes ../ and allowInsecureAccess is false (by default)', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -186,32 +164,28 @@ describe('Manager', () => {
         // Compilation errors sould be available for extensions.
 
         let error = null;
-        server.ext('onPostHandler', (request, reply) => {
+        server.ext('onPreResponse', (request, reply) => {
 
             const response = request.response;
             if (response.isBoom) {
                 error = response;
             }
 
-            reply.continue();
+            return reply.continue;
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: '../test', context: { message: 'Hello, World!' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(500);
-            expect(error).to.be.an.instanceof(Error);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(500);
+        expect(error).to.be.an.instanceof(Error);
     });
 
-    it('allows if path given includes ../ and allowInsecureAccess is true', (done) => {
+    it('allows if path given includes ../ and allowInsecureAccess is true', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             allowInsecureAccess: true,
@@ -220,20 +194,16 @@ describe('Manager', () => {
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: '../test', context: { message: 'Hello, World!' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.result).to.have.string('Hello, World!');
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.result).to.have.string('Hello, World!');
+        expect(res.statusCode).to.equal(200);
     });
 
-    it('errors if template does not exist()', (done) => {
+    it('errors if template does not exist()', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -242,32 +212,28 @@ describe('Manager', () => {
         // Compilation errors sould be available for extensions.
 
         let error = null;
-        server.ext('onPostHandler', (request, reply) => {
+        server.ext('onPreResponse', (request, reply) => {
 
             const response = request.response;
             if (response.isBoom) {
                 error = response;
             }
 
-            reply.continue();
+            return reply.continue;
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'testNope', context: { message: 'Hello, World!' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(500);
-            expect(error).to.be.an.instanceof(Error);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(500);
+        expect(error).to.be.an.instanceof(Error);
     });
 
-    it('errors if engine.compile throws', (done) => {
+    it('errors if engine.compile throws', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -276,32 +242,28 @@ describe('Manager', () => {
         // Compilation errors sould be available for extensions.
 
         let error = null;
-        server.ext('onPostHandler', (request, reply) => {
+        server.ext('onPreResponse', (request, reply) => {
 
             const response = request.response;
             if (response.isBoom) {
                 error = response;
             }
 
-            reply.continue();
+            return reply.continue;
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'badmustache', context: { message: 'Hello, World!' }, options: { path: __dirname + '/templates/valid/invalid' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(500);
-            expect(error).to.be.an.instanceof(Error);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(500);
+        expect(error).to.be.an.instanceof(Error);
     });
 
-    it('should not fail if rendered template returns undefined', (done) => {
+    it('should not fail if rendered template returns undefined', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: {
                 html: {
@@ -321,18 +283,14 @@ describe('Manager', () => {
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test.html' } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.statusCode).to.equal(200);
     });
 
-    it('allows the context to be modified by extensions', (done) => {
+    it('allows the context to be modified by extensions', async () => {
 
         const server = new Hapi.Server();
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { html: require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -342,20 +300,16 @@ describe('Manager', () => {
 
             const response = request.response;
             response.source.context.message = 'goodbye';
-
-            reply.continue();
+            return reply.continue;
         });
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test.html', context: { message: 'hello' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.result).not.to.contain('hello');
-            expect(res.result).to.contain('goodbye');
-            expect(res.statusCode).to.equal(200);
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.result).not.to.contain('hello');
+        expect(res.result).to.contain('goodbye');
+        expect(res.statusCode).to.equal(200);
     });
 
     describe('with engine initialization', () => {
@@ -564,11 +518,10 @@ describe('Manager', () => {
         });
     });
 
-    it('should not error on layoutKeyword conflict', (done) => {
+    it('should not error on layoutKeyword conflict', async () => {
 
         const server = new Hapi.Server({ debug: false });
-        server.connection();
-        server.register(Vision, Hoek.ignore);
+        await server.register(Vision);
         server.views({
             engines: { 'html': require('handlebars') },
             path: __dirname + '/templates/valid'
@@ -578,22 +531,18 @@ describe('Manager', () => {
 
         server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello, World!', content: 'fail' } } } });
 
-        server.inject('/', (res) => {
-
-            expect(res.result).to.exist();
-            expect(res.statusCode).to.equal(200);
-            expect(res.payload).to.contain('Hello, World!');
-            done();
-        });
+        const res = await server.inject('/');
+        expect(res.result).to.exist();
+        expect(res.statusCode).to.equal(200);
+        expect(res.payload).to.contain('Hello, World!');
     });
 
-    describe('with layout', (done) => {
+    describe('with layout', () => {
 
-        it('returns response', (done) => {
+        it('returns response', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -602,20 +551,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('<!DOCTYPE html>\n<html>\n    <head>\n        <title>test</title>\n    </head>\n    <body>\n        <div>\n    <h1>Hapi</h1>\n</div>\n\n    </body>\n</html>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('<!DOCTYPE html>\n<html>\n    <head>\n        <title>test</title>\n    </head>\n    <body>\n        <div>\n    <h1>Hapi</h1>\n</div>\n\n    </body>\n</html>\n');
         });
 
-        it('returns response with relativeTo and absolute path', (done) => {
+        it('returns response with relativeTo and absolute path', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 relativeTo: '/none/shall/pass',
@@ -625,20 +570,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('<!DOCTYPE html>\n<html>\n    <head>\n        <title>test</title>\n    </head>\n    <body>\n        <div>\n    <h1>Hapi</h1>\n</div>\n\n    </body>\n</html>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('<!DOCTYPE html>\n<html>\n    <head>\n        <title>test</title>\n    </head>\n    <body>\n        <div>\n    <h1>Hapi</h1>\n</div>\n\n    </body>\n</html>\n');
         });
 
-        it('returns response with layout override', (done) => {
+        it('returns response with layout override', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -647,20 +588,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' }, options: { layout: 'otherLayout' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('test:<div>\n    <h1>Hapi</h1>\n</div>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('test:<div>\n    <h1>Hapi</h1>\n</div>\n');
         });
 
-        it('returns response with custom server layout', (done) => {
+        it('returns response with custom server layout', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -669,20 +606,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('test:<div>\n    <h1>Hapi</h1>\n</div>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('test:<div>\n    <h1>Hapi</h1>\n</div>\n');
         });
 
-        it('returns response with custom server layout and path', (done) => {
+        it('returns response with custom server layout and path', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 relativeTo: __dirname,
@@ -693,20 +626,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('test+<div>\n    <h1>Hapi</h1>\n</div>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('test+<div>\n    <h1>Hapi</h1>\n</div>\n');
         });
 
-        it('errors on missing layout', (done) => {
+        it('errors on missing layout', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -716,31 +645,27 @@ describe('Manager', () => {
             // Compilation errors sould be available for extensions.
 
             let error = null;
-            server.ext('onPostHandler', (request, reply) => {
+            server.ext('onPreResponse', (request, reply) => {
 
                 const response = request.response;
                 if (response.isBoom) {
                     error = response;
                 }
 
-                reply.continue();
+                return reply.continue;
             });
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.statusCode).to.equal(500);
-                expect(error).to.be.an.instanceof(Error);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.statusCode).to.equal(500);
+            expect(error).to.be.an.instanceof(Error);
         });
 
-        it('errors on invalid layout', (done) => {
+        it('errors on invalid layout', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -750,31 +675,27 @@ describe('Manager', () => {
             // Compilation errors sould be available for extensions.
 
             let error = null;
-            server.ext('onPostHandler', (request, reply) => {
+            server.ext('onPreResponse', (request, reply) => {
 
                 const response = request.response;
                 if (response.isBoom) {
                     error = response;
                 }
 
-                reply.continue();
+                return reply.continue;
             });
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.statusCode).to.equal(500);
-                expect(error).to.be.an.instanceof(Error);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.statusCode).to.equal(500);
+            expect(error).to.be.an.instanceof(Error);
         });
 
-        it('returns response without layout', (done) => {
+        it('returns response without layout', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates',
@@ -783,20 +704,16 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'valid/test', context: { title: 'test', message: 'Hapi' }, options: { layout: false } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                expect(res.result.replace(/\r/g, '')).to.equal('<div>\n    <h1>Hapi</h1>\n</div>\n');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
+            expect(res.result.replace(/\r/g, '')).to.equal('<div>\n    <h1>Hapi</h1>\n</div>\n');
         });
 
-        it('errors on layoutKeyword conflict', (done) => {
+        it('errors on layoutKeyword conflict', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates/valid',
@@ -807,19 +724,15 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello, World!', content: 'fail' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(500);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(500);
         });
 
-        it('errors absolute path given and allowAbsolutePath is false (by default)', (done) => {
+        it('errors absolute path given and allowAbsolutePath is false (by default)', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 engines: { 'html': require('handlebars') },
                 path: __dirname + '/templates/valid',
@@ -829,35 +742,31 @@ describe('Manager', () => {
             // Compilation errors sould be available for extensions.
 
             let error = null;
-            server.ext('onPostHandler', (request, reply) => {
+            server.ext('onPreResponse', (request, reply) => {
 
                 const response = request.response;
                 if (response.isBoom) {
                     error = response;
                 }
 
-                reply.continue();
+                return reply.continue;
             });
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { title: 'test', message: 'Hapi' }, options: { path: __dirname + '/templates/valid/invalid' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(500);
-                expect(error).to.be.an.instanceof(Error);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(500);
+            expect(error).to.be.an.instanceof(Error);
         });
     });
 
     describe('with multiple engines', () => {
 
-        it('renders handlebars template', (done) => {
+        it('renders handlebars template', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 path: __dirname + '/templates/valid',
                 engines: {
@@ -876,19 +785,15 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'test.html', context: { message: 'Hello World!' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
         });
 
-        it('renders pug template', (done) => {
+        it('renders pug template', async () => {
 
             const server = new Hapi.Server();
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 path: __dirname + '/templates/valid',
                 engines: {
@@ -907,19 +812,15 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'testMulti.pug', context: { message: 'Hello World!' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.result).to.exist();
-                expect(res.statusCode).to.equal(200);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.result).to.exist();
+            expect(res.statusCode).to.equal(200);
         });
 
-        it('returns 500 on unknown extension', (done) => {
+        it('returns 500 on unknown extension', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 path: __dirname + '/templates/valid',
                 engines: {
@@ -938,18 +839,14 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'test', context: { message: 'Hello World!' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.statusCode).to.equal(500);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.statusCode).to.equal(500);
         });
 
-        it('returns 500 on missing extension engine', (done) => {
+        it('returns 500 on missing extension engine', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.connection();
-            server.register(Vision, Hoek.ignore);
+            await server.register(Vision);
             server.views({
                 path: __dirname + '/templates/valid',
                 engines: {
@@ -968,11 +865,8 @@ describe('Manager', () => {
 
             server.route({ method: 'GET', path: '/', handler: { view: { template: 'test.xyz', context: { message: 'Hello World!' } } } });
 
-            server.inject('/', (res) => {
-
-                expect(res.statusCode).to.equal(500);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.statusCode).to.equal(500);
         });
     });
 
@@ -1962,10 +1856,10 @@ describe('Manager', () => {
             });
 
             return views.render('test', { message: 'Hello!' }, null)
-            .then((content) => {
+                .then((content) => {
 
-                expect(content).to.contain('<h1>Hello!</h1>');
-            });
+                    expect(content).to.contain('<h1>Hello!</h1>');
+                });
         });
 
         it('returns a promise that is rejected on error if no callback is provided', () => {
@@ -1975,28 +1869,24 @@ describe('Manager', () => {
                 path: __dirname + '/templates/valid'
             });
 
-            return views.render('missing', null, null)
-            .then(
-                () => {
+            return views.render('missing', null, null).then(() => {
 
-                    throw new Error('should not resolve');
-                },
-                (err) => {
+                throw new Error('should not resolve');
+            },
+            (err) => {
 
-                    expect(err).to.exist();
-                    expect(err.message).to.contain('missing.html');
-                }
-            );
+                expect(err).to.exist();
+                expect(err.message).to.contain('missing.html');
+            });
         });
     });
 
     describe('_response()', () => {
 
-        it('sets Content-Type', (done) => {
+        it('sets Content-Type', async () => {
 
             const server = new Hapi.Server();
-            server.register(Vision, Hoek.ignore);
-            server.connection();
+            await server.register(Vision);
             server.views({
                 engines: { html: require('handlebars') },
                 path: __dirname + '/templates/valid'
@@ -2008,18 +1898,14 @@ describe('Manager', () => {
             };
 
             server.route({ method: 'GET', path: '/', handler });
-            server.inject('/', (res) => {
-
-                expect(res.headers['content-type']).to.contain('text/html');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.headers['content-type']).to.contain('text/html');
         });
 
-        it('does not override Content-Type', (done) => {
+        it('does not override Content-Type', async () => {
 
             const server = new Hapi.Server();
-            server.register(Vision, Hoek.ignore);
-            server.connection();
+            await server.register(Vision);
 
             server.views({
                 engines: { html: require('handlebars') },
@@ -2032,18 +1918,14 @@ describe('Manager', () => {
             };
 
             server.route({ method: 'GET', path: '/', handler });
-            server.inject('/', (res) => {
-
-                expect(res.headers['content-type']).to.contain('text/plain');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.headers['content-type']).to.contain('text/plain');
         });
 
-        it('errors on invalid template', (done) => {
+        it('errors on invalid template', async () => {
 
             const server = new Hapi.Server({ debug: false });
-            server.register(Vision, Hoek.ignore);
-            server.connection();
+            await server.register(Vision);
             server.views({
                 engines: { html: require('handlebars') },
                 path: __dirname + '/templates/invalid'
@@ -2055,18 +1937,14 @@ describe('Manager', () => {
             };
 
             server.route({ method: 'GET', path: '/', handler });
-            server.inject('/', (res) => {
-
-                expect(res.statusCode).to.equal(500);
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.statusCode).to.equal(500);
         });
 
-        it('passes the response object to the global context function', (done) => {
+        it('passes the response object to the global context function', async () => {
 
             const server = new Hapi.Server();
-            server.register(Vision, Hoek.ignore);
-            server.connection();
+            await server.register(Vision);
             server.views({
                 engines: { html: Handlebars },
                 path: __dirname + '/templates/valid',
@@ -2089,12 +1967,9 @@ describe('Manager', () => {
             };
 
             server.route({ method: 'GET', path: '/', handler });
-            server.inject('/', (res) => {
-
-                expect(res.payload).to.contain('<h1>/</h1>');
-                expect(res.payload).to.contain('<h1>global</h1>');
-                done();
-            });
+            const res = await server.inject('/');
+            expect(res.payload).to.contain('<h1>/</h1>');
+            expect(res.payload).to.contain('<h1>global</h1>');
         });
     });
 });