node.js - unitarias - Pruebas de moca con opciones o parámetros extra

pruebas unitarias node js

Question

Estoy escribiendo casos de prueba para mi aplicación Node.js usando Mocha. Los casos de prueba necesitan una clave API como una opción o parámetro de entrada adicional. La clave 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 para permitir que los evaluadores especifiquen su propia clave API para la prueba en la línea de comandos? Como:

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

Answer 1

Eche un vistazo al módulo optimist de Substack y nconf de nconf . Muchas de mis pruebas dependen de parámetros externos y los módulos optimista y nconf facilitan la carga de las 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 config . Puede especificar un archivo ./config/default.yml para ejecutar con regularidad y un archivo ./config/test.yml para las pruebas.

Cuando ejecute su conjunto de pruebas, exporte NODE_ENV = prueba y el módulo de configuración 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 fácil de configurar NODE_ENV = prueba es ejecutando sus pruebas con un makefile. Ejecutar todas sus pruebas a través de make test . Para ejecutar una sola prueba, ejecute make one NAME=test/unit/sample-test.js

Muestra makefile

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

Answer 2

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

Digamos que tengo config.yml o config.json . En mi caso es un archivo YAML.

En primer lugar instalo la dependencia yamljs . Tiene una función llamada load .

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.

Answer 3

Las otras respuestas están limitadas porque no admiten la ejecución de código antes de ejecutar su conjunto de pruebas. Sólo soportan pasar parámetros.

Esta respuesta admite la ejecución de código ANTES de que su suite de pruebas se ejecute y esté completamente documentado 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 la rutina de arranque del servidor se ejecutará antes de la prueba y la ejecución del servidor (inicio npm y prueba npm)

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

Gracias a @damianfabian por esto, vea ¿Cómo inicializar una variable global en las pruebas de unidad?

Answer 4

No creo que Mocha 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éelos en tus archivos de prueba:

var key = process.env.KEY;

Answer 5

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

Dicho esto, si pasa su clave al final de la línea de comandos (después del archivo a 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

Answer 6

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;

Answer 7

Puede pasar un argumento al script de prueba mocha usando el módulo ''minimista''. Instalar con npm install minimist

Terminal:

mocha test.js --config=VALUE

Script de nodo Mocha:

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

Answer 8

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

comando de prueba:

npm --somevariable=myvalue run mytest

paquete.json:

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

test.js

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

Answer 9

Una forma sencilla, utilizando process.argv que contiene los argumentos de la línea de comandos

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

Más tarde, puede obtener YOUR_KEY en su 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 el proceso.argv

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

Salida

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

KEY:  YOUR_KEY
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_KEY

KEY:  YOUR_KEY
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_KEY