Refactor out middleware, organise dir structure and more test coverage

Author: samtgarson

.circleci/config.yml

@@ -30,3 +30,5 @@ jobs:
       # run tests!
       - run: yarn test
 
+      - store_artifacts:
+          path: ./coverage

.gitignore

@@ -3,3 +3,4 @@ node_modules
 /yarn-error.log
 doc
 /doc.html
+/coverage

index.js

@@ -1,15 +1,10 @@
 const path = require('path')
-
-const middleware = keys => (req, res, next) => {
-  if (!req.env) req.env = {}
-  keys.forEach(key => req.env[key] = process.env[key])
-  next()
-}
+const middleware = require('./lib/middleware')
 
 module.exports = function NuxtEnv ({ keys }) {
   this.addServerMiddleware(middleware(keys))
 
-  const src = path.resolve(__dirname, 'plugin.js')
+  const src = path.resolve(__dirname, 'lib/plugin.js')
   this.addPlugin({
     src,
     filename: 'nuxt-env'

lib/middleware.js

@@ -0,0 +1,5 @@
+module.exports = (keys = []) => (req = {}, res, next = () => {}) => {
+  if (!req.env) req.env = {}
+  keys.forEach(key => req.env[key] = process.env[key])
+  next()
+}

plugin.js lib/plugin.jsplugin.js renamed to lib/plugin.js

@@ -1,14 +1,14 @@
 {
   "name": "nuxt-env",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Inject env vars for your Nuxt app at runtime",
   "main": "index.js",
   "repository": "https://github.com/samtgarson/nuxt-env",
   "author": "samtgarson@gmail.com",
   "license": "MIT",
   "scripts": {
     "test": "yarn test:unit && yarn test:lint",
-    "test:unit": "NODE_ENV=test jest",
+    "test:unit": "NODE_ENV=test jest --coverage",
     "test:lint": "eslint --ignore-path .gitignore  --ignore-pattern '/doc/**' ."
   },
   "babel": {

package.json

@@ -1,12 +1,11 @@
+import { Nuxt, Builder } from 'nuxt'
+import request from 'request-promise-native'
+import config from './support/app/nuxt.config'
+
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 20000
 process.env.PORT = process.env.PORT || 5060
 process.env.NODE_ENV = 'production'
 
-const { Nuxt, Builder } = require('nuxt')
-const request = require('request-promise-native')
-
-const config = require('./support/app/nuxt.config')
-
 const url = path => `http://localhost:${process.env.PORT}${path}`
 const get = path => request({
   followRedirect: req => req.headers.location.startsWith('/'),

test/e2e.js

@@ -0,0 +1,32 @@
+import module from '@/index'
+
+jest.mock('@/lib/middleware', () => jest.fn(() => 'middleware result'))
+
+const FakeModule = {
+  addServerMiddleware: jest.fn(),
+  addPlugin: jest.fn()
+}
+
+const subject = module.bind(FakeModule)
+const args = {
+  keys: ['TEST_ENV']
+}
+
+describe('Module', () => {
+  it('adds the server middleware', () => {
+    subject(args)
+
+    expect(FakeModule.addServerMiddleware)
+      .toHaveBeenCalledWith('middleware result')
+  })
+
+  it('adds the plugin', () => {
+    subject(args)
+
+    expect(FakeModule.addPlugin).toHaveBeenCalled()
+    const { calls: { 0: { 0: calls } } } = FakeModule.addPlugin.mock
+
+    expect(calls.filename).toEqual('nuxt-env')
+    expect(calls.src).toMatch(/lib\/plugin\.js/)
+  })
+})

test/index.js

@@ -0,0 +1,34 @@
+import Middleware from '@/lib/middleware'
+
+describe('Middleware', () => {
+  it('creates a middleware function', () => {
+    const middleware = Middleware()
+
+    expect(middleware).toBeInstanceOf(Function)
+  })
+
+  it('adds env to the request', () => {
+    const expectedKey = 'TEST_VALUE'
+    const expectedValue = 'test value'
+    const req = { env: {} }
+    const middleware = Middleware([expectedKey])
+    process.env[expectedKey] = expectedValue
+
+    middleware(req, {})
+
+    expect(req.env).toHaveProperty(expectedKey, expectedValue)
+  })
+
+  it('calls next when its finished', () => {
+    const middleware = Middleware()
+    const next = jest.fn()
+    middleware({}, {}, next)
+
+    expect(next).toHaveBeenCalled()
+  })
+
+  it('handles empty arguments', () => {
+    const middleware = Middleware()
+    expect(() => { middleware() }).not.toThrow()
+  })
+})

test/lib/middleware.js

@@ -0,0 +1,90 @@
+import plugin from '@/lib/plugin'
+
+let inject
+let context
+const originalContext = {
+  beforeNuxtRender: jest.fn(),
+  env: {
+    test1: 'foo',
+    test2: 'bar'
+  },
+  nuxtState: {
+    env: {}
+  }
+}
+
+const expectedEnv = {
+  test1: 'foo', // from the config env
+  test2: 'baz', // from config env, overwritten by nuxt-env
+  test3: 'foobar' // from nuxt-env
+}
+
+beforeEach(() => {
+  inject = jest.fn()
+  context = { ...originalContext }
+})
+
+describe('Plugin', () => {
+  describe('client side', () => {
+    beforeEach(() => {
+      context.isClient = true
+      plugin(context, inject)
+    })
+
+    it('injects the env', () => {
+      expect(inject).toHaveBeenCalledWith('env', context.nuxtState.env)
+    })
+  })
+
+  describe('server side', () => {
+    const reqEnv = { test2: 'baz', test3: 'foobar' }
+
+    beforeEach(() => {
+      context.isClient = false
+    })
+
+    describe('in a normal case', () => {
+      beforeEach(() => {
+        context.req = { env: reqEnv }
+        plugin(context, inject)
+      })
+
+      it('injects the env', () => {
+        expect(inject).toHaveBeenCalled()
+        const { calls: { 0: { 0: calls } } } = inject.mock
+        expect(calls).toEqual('env')
+      })
+
+      it('merges the two env vars', () => {
+        const { calls: { 0: { 1: calls } } } = inject.mock
+        expect(calls).toMatchObject(expectedEnv)
+      })
+
+      it('calls before render hook with a callback', () => {
+        expect(context.beforeNuxtRender).toHaveBeenCalled()
+        const { calls: { 0: { 0: hookCallback } } } = context.beforeNuxtRender.mock
+
+        expect(hookCallback).toBeInstanceOf(Function)
+      })
+
+      it('adds env to nuxtState', () => {
+        const { calls: { 0: { 0: hookCallback } } } = context.beforeNuxtRender.mock
+
+        hookCallback(context)
+
+        expect(context.nuxtState.env).toMatchObject(expectedEnv)
+      })
+    })
+
+    describe('with missing dependencies', () => {
+      beforeEach(() => {
+        delete context.env
+      })
+
+      it('has sensible defaults', () => {
+        const runPlugin = () => { plugin(context, inject) }
+        expect(runPlugin).not.toThrow()
+      })
+    })
+  })
+})