Estoy escribiendo casos de prueba para mi aplicación Node.js usando Mocha. Los casos de prueba necesitan una clave API como parámetro o opción de entrada adicional. La clave de API es privada, por lo que no quiero incluirla directamente en los archivos de prueba, ya que todos pueden verla en GitHub. Sé que hay algunas opciones disponibles para Mocha en:

http://mochajs.org/#usage

Pero, ¿es posible incluir algunos parámetros que permitan a los evaluadores especificar su propia clave API para la prueba en la línea de comandos? Como:

./node_modules/mocha/bin/mocha test/*.js --key YOUR_KEY

No creo que Mocha en sí admita pasar parámetros adicionales a sus pruebas, pero podría usar variables de entorno:

env KEY=YOUR_KEY mocha test/*.js # assumes some sort of Unix-type OS.

Y léalos en sus archivos de prueba:

var key = process.env.KEY;

Eche un vistazo al módulo optimist de Substack y nconf de flatiron. Muchas de mis pruebas dependen de parámetros externos y los módulos optimist y nconf facilitan la carga de opciones de configuración desde un archivo json

En su comando de prueba, pase la ruta al archivo config.json

comando de prueba

mocha test/api-test.js --config=/path/to/config.json --reporter spec

api-test.js

var path = require('path')
var fs = require('fs')
var assert = require('assert')
var argv = require('optimist').demand('config').argv
var configFilePath = argv.config
assert.ok(fs.existsSync(configFilePath), 'config file not found at path: ' + configFilePath)
var config = require('nconf').env().argv().file({file: configFilePath})
var apiConfig = config.get('api')
var apiKey = apiConfig.key

config.json

{
  "api": {
    "key": "fooKey",
    "host": "example.com",
    "port": 9000
  }
}

Alternativa

Otro patrón que he estado usando recientemente es el módulo de configuración . Puede especificar un ./config/default.ymlarchivo para ejecutar con regularidad y un ./config/test.ymlarchivo para pruebas.

Cuando ejecute su suite de prueba, exporte NODE_ENV = test y el módulo de configuración se cargará test.yml

En su código es fácil acceder al objeto de configuración

var config = require('config')

// config now contains your actual configuration values as determined by the process.env.NODE_ENV
var apiKey = config.api.key

Una forma sencilla de configurar NODE_ENV = test es ejecutar sus pruebas con un archivo MAKE. Ejecute todas sus pruebas a través de make test. Para ejecutar una sola prueba, ejecutemake one NAME=test/unit/sample-test.js

Archivo MAKE de muestra

MOCHA?=node_modules/.bin/mocha
REPORTER?=spec
GROWL?=--growl
FLAGS=$(GROWL) --reporter $(REPORTER) --colors --bail

test:
        @NODE_ENV="test" \
        $(MOCHA) $(shell find test -name "*-test.js") $(FLAGS)

one:
        @NODE_ENV="test" \
        $(MOCHA) $(NAME) $(FLAGS)

unit:
        @NODE_ENV="test" \
        $(MOCHA) $(shell find test/unit -name "*-test.js") $(FLAGS)

integration:
        @NODE_ENV="test" \
        $(MOCHA) $(shell find test/integration -name "*-test.js") $(FLAGS)

acceptance:
        @NODE_ENV="test" \
        $(MOCHA) $(shell find test/acceptance -name "*-test.js") $(FLAGS)

.PHONY: test

Una de las formas más fáciles de pasar parámetros similares al método process.argv [index] mencionado en este hilo es usando las variables de configuración npm. Esto le permite ver el nombre de la variable con un poco más de claridad:

comando de prueba:

npm --somevariable=myvalue run mytest

package.json:

"scripts": {
"mytest": "mocha ./test.js" }

test.js

console.log(process.env.npm_config_somevariable) // should evaluate to "myvalue"

Las otras respuestas están limitadas porque no admiten la ejecución de código antes de ejecutar su conjunto de pruebas. Solo admiten el paso de parámetros.

Esta respuesta admite la ejecución de código ANTES de que se ejecute su suite de prueba y está completamente documentada por mocha

documentos de mocha: http://unitjs.com/guide/mocha.html#mocha-opts

crear ./test/mocha.opts

--recursive
--reporter spec
--require ./server.bootstrap
--require ./test/test.bootstrap

crear ./server.bootstrap.js

global.appRoot = require('app-root-path');
// any more server init code

crear ./test/test.bootstrap.js

process.env.NODE_ENV='test';
// any more test specific init code

finalmente en su server.js:

require('./server.bootstrap');

¡HECHO!

El código en el arranque del servidor se ejecutará antes de la prueba y la ejecución del servidor (npm start y npm test)

El código en el bootstrap de prueba solo se ejecutará antes de la prueba (prueba npm)

Gracias a @damianfabian por este: consulte ¿Cómo inicializar una variable global en ejecuciones de prueba unitarias?

No hay una forma compatible de hacer esto con Mocha. la forma sugerida es usar un archivo (por ejemplo config.json), requerirlo y dejar que otras personas lo cambien.

Dicho esto, si pasa su clave al final de la línea de comando (después del archivo para probar) y la usa, debería estar disponible usando process.argv (si no la usa, o no después de un archivo normal nombre, entonces mocha fallará).

si ejecuta ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKey, y test.js contiene el código:

var assert = require("assert")
describe("testy", function () {
    it("shouldy", function (done) {
        var value;
        for (var index in process.argv) {
            var str = process.argv[index];
            if (str.indexOf("--apiKey") == 0) {
                value = str.substr(9);
            }
        }
        assert.equal(value,"someKey")
        done();
    })
})

la prueba debe pasar

Puede pasar un argumento a la secuencia de comandos de prueba mocha utilizando el módulo 'minimista'. Instalar connpm install minimist

Terminal:

mocha test.js --config=VALUE

Secuencia de comandos de nodo Mocha:

var argv = require('minimist')(process.argv.slice(2));
console.log('config', argv.config);

Una forma sencilla, usando process.argv que contiene los argumentos de línea de comando

$ mocha  -w test/*.js --KEY=YOUR_VALUE

Más tarde, puede ingresar YOUR_VALUEsu código:

let LAST_PARAM = process.argv[process.argv.length-1]

let PARAM_NAME  = LAST_PARAM.split("=")[0].replace("--","")
let PARAM_VALUE = LAST_PARAM.split("=")[1]

console.log("KEY: ", PARAM_VALUE)

Para ver todo process.argv:

process.argv.forEach((value, index) => {
        console.log(`process.argv[${index}]: ${value}`);
})

Salida:

$ mocha  -w test/*.js --KEY=YOUR_VALUE

KEY:  YOUR_VALUE
process.argv[0]: /usr/local/bin/node
process.argv[1]: /Users/pabloin/.npm-packages/lib/node_modules/mocha/bin/_mocha
process.argv[2]: -w
process.argv[3]: test/tt.js
process.argv[4]: test/tt2.js
process.argv[5]: --KEY=YOUR_VALUE

KEY:  YOUR_VALUE
process.argv[0]: /usr/local/bin/node
process.argv[1]: /Users/pabloin/.npm-packages/lib/node_modules/mocha/bin/_mocha
process.argv[2]: -w
process.argv[3]: test/tt.js
process.argv[4]: test/tt2.js
process.argv[5]: --KEY=YOUR_VALUE

Podría enviar el parámetro pensamiento mochaStream (require ('spawn-mocha-parallel'). MochaStream).

me gusta:

var mochaStream = require('spawn-mocha-parallel').mochaStream;

var mocha = mochaStream({
    env: function(){
        return {yourParam: 'value'}
    }
});

return gulp.src('test/**/*-specs.js', {read: false})
    .pipe(mochaStream)
    .on('error', console.warn.bind(console));

Dentro del archivo ..spec.js

var yourParam = process.env.yourParam;

He estado leyendo bastantes respuestas, la mayoría de ellas más complejas de lo que tiene que ser la solución real.

Digamos que tengo config.ymloconfig.json . En mi caso, es un archivo YAML.

Primero que nada instalo la yamljsdependencia. Tiene una función llamadaload .

Básicamente lo que hago:

const YAML = require('yamljs'); const ymlConfig = YAML.load('./config.yml');

Entonces voy por:

process.env.setting1 = ymlConfig.setting1; process.env.setting2 = ymlConfig.setting2;

Y, por supuesto, todo esto se hace en su archivo de prueba.

si está depurando / probando con la barra lateral de Mocha (extensión VS Code), simplemente póngalo:

{
    "mocha.env": {
        "KEY": "YOUR_KEY",
        "MY_VARIABLE": "MY VALUE"
    }
}

a .vscode/settings.json