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:
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
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;
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.
mocha test/api-test.js --config=/path/to/config.json --reporter spec
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
{
"api": {
"key": "fooKey",
"Host": "example.com",
"port": 9000
}
}
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
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
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
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?
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"
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);
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;
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
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.
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