web-dev-qa-db-fra.com

Tests moka avec options ou paramètres supplémentaires

J'écris des scénarios de test pour mon application Node.js à l'aide de Mocha. Les scénarios de test nécessitent une clé API en tant qu'option ou paramètre supplémentaire. La clé API est privée, je ne souhaite donc pas l'inclure directement dans les fichiers de test, car tout le monde peut alors le voir sur GitHub. Je sais qu'il existe quelques options pour Mocha à l'adresse suivante:

http://mochajs.org/#usage

Mais est-il possible d'inclure certains paramètres pour permettre aux testeurs de spécifier leur propre clé API pour le test dans la ligne de commande? Tel que:

./node_modules/mocha/bin/mocha test/*.js --key YOUR_KEY
node.jsmocha
64
afterglowlee

Je ne pense pas que Mocha lui-même prenne en charge le passage de paramètres supplémentaires à vos tests, mais vous pouvez utiliser des variables d'environnement:

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

Et lisez-les dans vos fichiers de test:

var key = process.env.KEY;
70
robertklep

Regardez le module optimist de Substack et nconf de flatiron. Beaucoup de mes tests dépendent de paramètres externes et les modules optimist et nconf facilitent le chargement des options de configuration à partir d'un fichier json

Dans votre commande de test, indiquez le chemin d'accès au fichier config.json. 

commande de test

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
  }
}

Alternative

Un autre motif que j’ai utilisé récemment est le module config . Vous pouvez spécifier un fichier ./config/default.yml pour une exécution régulière et un fichier ./config/test.yml pour des tests.

Lors de l'exécution de votre suite de tests, exportez NODE_ENV = test et le module de configuration chargera test.yml

Dans votre code, il est facile d'accéder à l'objet de configuration

var config = require('config')

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

Un moyen facile de définir NODE_ENV = test consiste à exécuter vos tests avec un fichier makefile. Exécutez tous vos tests via make test. Pour exécuter un seul test, exécutez make one NAME=test/unit/sample-test.js

Exemple de 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
24
Noah

Il n’existe aucun moyen de faire cela avec Mocha. la méthode suggérée consiste à utiliser un fichier (par exemple, config.json), à en avoir besoin et à laisser les autres le modifier.

Cela étant dit, si vous passez votre clé à la fin de la ligne de commande (après le fichier à tester) et utilisez - elle devrait être disponible à l'aide de process.argv (si vous n'utilisez pas - ou ce n'est pas après un fichier normal nom, alors le moka échouera).

si vous exécutez ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKey et que test.js contient le code suivant:

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();
    })
})

le test devrait passer

19
Alon Bar David

Les autres réponses sont limitées en ce qu'elles ne prennent pas en charge l'exécution de code avant l'exécution de votre suite de tests. Ils ne supportent que les paramètres de passage.

Cette réponse prend en charge l'exécution du code AVANT que votre suite de tests soit exécutée et est entièrement documentée par mocha

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

créer ./test/mocha.opts

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

créer ./server.bootstrap.js

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

créer ./test/test.bootstrap.js

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

enfin dans votre server.js:

require('./server.bootstrap');

TERMINÉ!

Le code dans l'amorçage du serveur sera exécuté avant les tests et l'exécution du serveur (npm start et npm test)

Le code dans le test d'amorçage ne sera exécuté qu'avant le test (test npm)

Merci à @damianfabian pour celui-ci - voir Comment initialiser une variable globale dans les tests unitaires?

17
danday74

L'un des moyens les plus simples de passer des paramètres similaires à la méthode process.argv [index] mentionnée dans ce fil consiste à utiliser les variables de configuration npm. Cela vous permet de voir le nom de la variable un peu plus clairement:

commande de test: 

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"
17
Adam Levine

Vous pouvez passer un argument au script de test mocha en utilisant le module 'minimiste'. Installer avec npm install minimist

Terminal:

mocha test.js --config=VALUE

Script de noeud Mocha:

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

Je pourrais envoyer un paramètre pensé mochaStream (require ('spawn-mocha-parallel'). MochaStream).

comme:

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));

Dans le fichier ..spec.js

var yourParam = process.env.yourParam;
2
SM Adnan

Un moyen simple, en utilisant process.argv qui contient les arguments de ligne de commande

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

Plus tard, vous pourrez obtenir YOUR_KEY dans votre code:

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)

Pour voir tous les process.argv 

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

Sortie

$ 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
1
Pablo Ezequiel

J'ai lu pas mal de réponses, la plupart d'entre elles plus complexes que la solution réelle.

Disons que j'ai config.yml ou config.json. Dans mon cas, c'est un fichier YAML.

Tout d'abord, j'installe la dépendance yamljs. Il a une fonction appelée load.

En gros ce que je fais:

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

Alors je pars pour:

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

Et bien sûr, tout cela est fait dans votre fichier de test.

1
Bilger Yahov

si vous êtes en train de déboguer/tester avec la barre latérale Mocha (extension de code VS), indiquez-le simplement:

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

à .vscode/settings.json

0
fsilva