Create a loadEnvs api function (#289)

- test without test double in mocha
- proxyquire isn't great but it's better
- a little bit of refactoring

Author: reconbot

.eslintrc

@@ -5,7 +5,7 @@
   },
   "globals": {
     "assert": false,
-    "td": false
+    "proxyquire": false
   },
   "extends": [
     "standard",

package.json

@@ -78,6 +78,7 @@
     "eslint-plugin-standard": "^3.0.1",
     "mocha": "^3.4.2",
     "np": "^2.12.0",
+    "proxyquire": "^1.8.0",
     "testdouble": "^2.1.2"
   },
   "babel": {

src/index.js

@@ -13,4 +13,5 @@ export { default as configSet } from './config-set'
 export { default as configRemove } from './config-remove'
 export { default as configList } from './config-list'
 export { default as configSync } from './config-sync'
+export { envs as loadEnvs } from './util/load'
 export { version } from '../package.json'

src/util/aws/lambda.js

@@ -181,11 +181,11 @@ export async function isFunctionDeployed (FunctionName, Qualifier) {
 
   try {
     await getFunction({ FunctionName, Qualifier })
-    return true
   } catch (err) {
     if (err.code === 'ResourceNotFoundException') { return false }
     throw err
   }
+  return true
 }
 
 export async function doesAliasExist ({ FunctionName, Alias }) {
@@ -194,11 +194,11 @@ export async function doesAliasExist ({ FunctionName, Alias }) {
 
   try {
     await lambda.getAlias({ FunctionName, Name: Alias }).promise()
-    return true
   } catch (err) {
     if (err.code === 'ResourceNotFoundException') { return false }
     throw err
   }
+  return true
 }
 
 export async function getEnvironment (env, { FunctionName }) {
@@ -215,8 +215,10 @@ export async function getEnvironment (env, { FunctionName }) {
     .get('Variables')
     return envVars
   } catch (e) {
-    if (e.code !== 'ResourceNotFoundException') { throw e }
-    throw new AWSEnvironmentVariableNotFound(FunctionName)
+    if (e.code === 'ResourceNotFoundException') {
+      throw new AWSEnvironmentVariableNotFound(FunctionName)
+    }
+    throw e
   }
 }
 
@@ -230,7 +232,7 @@ export async function getAliasVersion ({ functionName, aliasName }) {
   }
 
   return lambda.getAlias(params).promise()
-  .get('FunctionVersion')
+    .get('FunctionVersion')
 }
 
 export async function setPermission ({ name, region, env, apiId, accountId }) {

src/util/build-functions.js

@@ -5,8 +5,8 @@ export default async function (PATTERN, NODE_ENV) {
   const { shep } = await pkg()
   const buildCommand = (shep && shep.buildCommand) || 'webpack --bail'
   return exec(buildCommand, { env: { ...process.env, PATTERN, NODE_ENV } })
-  .catch({ code: 'ENOENT' }, (e) => {
-    console.warn('No locally installed webpack found. Verify that webpack is installed')
-    throw e
-  })
+    .catch({ code: 'ENOENT' }, (e) => {
+      console.warn('No locally installed webpack found. Verify that webpack is installed')
+      throw e
+    })
 }

src/util/load.js

@@ -1,28 +1,33 @@
+import isEqual from 'lodash.isequal'
 import path from 'path'
+import Promise from 'bluebird'
 import { readdir, readJSON } from './modules/fs'
 import minimatch from 'minimatch'
 import { listAliases, isFunctionDeployed } from './aws/lambda'
-import Promise from 'bluebird'
 
 export async function envs () {
-  const fullFuncNames = await Promise.map(this.funcs(), this.lambdaConfig)
-  .map(({ FunctionName }) => FunctionName)
+  const functionLambdaConfigs = await Promise.map(funcs(), lambdaConfig).map(({ FunctionName }) => FunctionName)
 
-  const deployedFunctions = await Promise.filter(fullFuncNames, (x) => isFunctionDeployed(x))
-  const allAliases = await Promise.map(deployedFunctions, (name) => listAliases(name).map(({ Name }) => Name))
+  const deployedFunctions = await Promise.filter(functionLambdaConfigs, (name) => isFunctionDeployed(name))
+  if (deployedFunctions.length <= 0) {
+    throw new Error('No deployed functions')
+  }
 
-  const aliases = allAliases.reduce((acc, aliasSet) => {
-    const missingAliases = aliasSet.filter((alias) => acc.indexOf(alias) === -1)
-          .concat(acc.filter((alias) => aliasSet.indexOf(alias) === -1))
+  const allFunctionAliases = await Promise.map(deployedFunctions, async name => {
+    const aliases = await listAliases(name).map(({ Name }) => Name)
+    return aliases.sort()
+  })
 
-    if (missingAliases.length !== 0) {
-      throw new EnvironmentMismatch()
-    }
-
-    return acc
-  }, allAliases.pop())
+  const aliases = allFunctionAliases.pop().sort()
+  if (aliases.length === 0) {
+    throw new AliasesNotFound()
+  }
 
-  if (!aliases || aliases.length === 0) { throw new AliasesNotFound() }
+  allFunctionAliases.forEach(functionAliases => {
+    if (!isEqual(aliases, functionAliases)) {
+      throw EnvironmentMismatch()
+    }
+  })
 
   return aliases
 }
@@ -44,16 +49,15 @@ export async function funcs (pattern = '*') {
   const funcs = await readdir('functions').filter(minimatch.filter(pattern))
   if (funcs.length === 0) {
     throw new FunctionNotFound(pattern)
-  } else {
-    return funcs
   }
+  return funcs
 }
 
 export async function lambdaConfig (name) {
   const functionConfig = await readJSON(`functions/${name}/lambda.json`)
   const projectConfig = await readJSON(`lambda.json`)
 
-  return Object.assign(projectConfig, functionConfig)
+  return Object.assign({}, projectConfig, functionConfig)
 }
 
 export async function pkg () {

src/util/modules/fs.js

@@ -1,11 +1,11 @@
 import fs from 'fs-extra-promise'
 
+export const exists = fs.existsAsync
 export const mkdirp = fs.mkdirpAsync
+export const readdir = fs.readdirAsync
+export const readdirSync = fs.readdirSync
 export const readFile = fs.readFileAsync
-export const writeFile = fs.writeFileAsync
-export const writeJSON = fs.writeJSONAsync
 export const readJSON = fs.readJSONAsync
 export const readJSONSync = fs.readJSONSync
-export const readdirSync = fs.readdirSync
-export const readdir = fs.readdirAsync
-export const exists = fs.existsAsync
+export const writeFile = fs.writeFileAsync
+export const writeJSON = fs.writeJSONAsync

test/build-test.js

@@ -1,39 +1,54 @@
 describe('shep.build', () => {
-  const exec = td.replace('../src/util/modules/exec')
-  td.when(exec(), { ignoreExtraArgs: true }).thenResolve()
-
   it('Executes custom command', async () => {
     const buildCommand = 'custom-build --cool-flag -x 6'
-    const load = td.replace('../src/util/load')
-    td.when(load.pkg()).thenResolve({ shep: { buildCommand } })
-    td.when(exec(), { ignoreExtraArgs: true }).thenResolve()
-    const shep = require('../src')
+    const exec = async (command) => {
+      assert.equal(command, buildCommand)
+    }
+    exec['@global'] = true
+    const shep = proxyquire('../src/', {
+      './load': {
+        '@global': true,
+        pkg: async () => { return { shep: { buildCommand } } }
+      },
+      './modules/exec': exec
+    })
 
-    td.when(exec(buildCommand), { ignoreExtraArgs: true }).thenResolve()
     await shep.build({ quiet: true })
   })
 
   it('Logs to console when no webpack found', async () => {
-    let error = new Error()
+    const error = new Error()
     error.code = 'ENOENT'
 
-    const load = td.replace('../src/util/load')
-    td.when(load.pkg()).thenResolve({ shep: {} })
+    const exec = async (command) => {
+      throw error
+    }
+    exec['@global'] = true
 
-    td.when(exec('webpack --bail'), { ignoreExtraArgs: true }).thenReject(error)
-    td.replace(console, 'warn')
+    const shep = proxyquire('../src/', {
+      './load': {
+        '@global': true,
+        pkg: async () => { return { shep: { } } }
+      },
+      './modules/exec': exec
+    })
 
-    const shep = require('../src')
-    error = await assert.isRejected(shep.build({ quiet: true }))
-    assert.equal(error.code, 'ENOENT')
-    td.verify(console.warn(), { ignoreExtraArgs: true })
+    assert.deepEqual(await assert.isRejected(shep.build({ quiet: true })), error)
   })
 
-  describe('Executed webpack', async () => {
-    const load = td.replace('../src/util/load')
-    const shep = require('../src')
-    td.when(load.pkg()).thenResolve({})
-    td.when(exec('webpack --bail'), { ignoreExtraArgs: true }).thenResolve()
+  it('Executed webpack', async () => {
+    const exec = async (command) => {
+      assert.equal(command, 'webpack --bail')
+    }
+    exec['@global'] = true
+
+    const shep = proxyquire('../src/', {
+      './load': {
+        '@global': true,
+        pkg: async () => { return { shep: { } } }
+      },
+      './modules/exec': exec
+    })
     await shep.build({ quiet: true })
   })
 })

test/initializers.js

@@ -1,9 +1,6 @@
-import td from 'testdouble'
-import Promise from 'bluebird'
 import chai from 'chai'
 import chaiAsPromised from 'chai-as-promised'
+import proxyquire from 'proxyquire'
 
 chai.use(chaiAsPromised)
-
-td.config({ promiseConstructor: Promise, ignoreWarnings: true })
-global.td = td
+global.proxyquire = proxyquire.noPreserveCache()

test/listenv-test.js

@@ -0,0 +1,38 @@
+describe('shep.listEnv', () => {
+  it('returns a list of environments', async () => {
+    const exec = async (command) => {
+      assert.equal(command, 'webpack --bail')
+    }
+    exec['@global'] = true
+
+    const shep = proxyquire('../src/', {
+      './load': {
+        '@global': true,
+        async pkg () { return { shep: {} } }
+      },
+      './modules/exec': exec,
+      './modules/fs': {
+        '@global': true,
+        async readdir () { return ['function1', 'function2'] },
+        async readJSON () { return {} }
+      },
+      './aws/lambda': {
+        '@global': true,
+        async isFunctionDeployed () { return true },
+        async listAliases () {
+          return [
+            { Name: 'beta' },
+            { Name: 'production' },
+            { Name: 'staging' }
+          ]
+        }
+      }
+    })
+
+    assert.deepEqual(await shep.loadEnvs(), [
+      'beta',
+      'production',
+      'staging'
+    ])
+  })
+})