regardez le optimist module par sous-paquet 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 test, passez le chemin de la configuration.dossier json

le test de la commande

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 modèle que j'ai utilisé récemment est le module config . Vous pouvez spécifier un fichier ./config/default.yml pour l'exécution régulière et un fichier ./config/test.yml pour les tests.

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

In 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 est d'exécuter vos tests avec un makefile. Faites tous vos tests via make test . Pour exécuter un seul essai, 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

il n'y a pas de méthode supportée pour faire ça avec Mocha. la manière suggérée est d'utiliser un fichier (par exemple config.json), l'exigent, et laisser d'autres personnes le changer.

cela étant dit, si vous passez votre clé à la fin de la ligne de commande (après le fichier à tester) et utiliser -- il devrait être disponible en utilisant le processus.argv (si vous n'utilisez pas -- ou ce n'est pas après un nom de fichier, puis moka échouera).

si vous lancez ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKey , et tester.js contient le code:

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

l'essai doit être réussi

un des moyens les plus faciles pour passer des paramètres similaires au processus.la méthode argv[index] mentionnée dans ce thread utilise les variables de configuration npm. Cela vous permet de voir le nom de la variable un peu plus clairement:

le test de la commande:

npm --somevariable=myvalue run mytest

paquet.json:

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

.js

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

vous pouvez passer un argument à mocha test script en utilisant le module 'minimist'. Installer avec npm install minimist

Terminal:

mocha test.js --config=VALUE

Moka le nœud de script:

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

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

cette réponse prend en charge l'exécution de code avant que votre suite de test ne soit exécutée et est entièrement documentée par mocha

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

de créer ./test/moka.opts

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

de créer ./serveur.bootstrap.js

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

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

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

enfin sur votre serveur.js:

require('./server.bootstrap');

fait!

le code dans le bootstrap du serveur sera exécuté avant les tests et l'exécution du serveur (npm start et npm test)

le code dans le bootstrap de test ne sera exécuté qu'avant le test (npm test)

merci à @damianfabian pour celle-ci-voir comment initialiser une variable globale dans les essais unitaires?

je pourrais envoyer la pensée de paramètre 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));

à l'intérieur ..specs.fichier js

var yourParam = process.env.yourParam;

une manière simple, en utilisant le processus.argv qui contiennent la ligne de commande args

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

plus tard, vous pouvez obtenir VOTRE_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 processus.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 beaucoup de réponses, la plupart plus complexes que la solution réelle doit être.

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 .

fondamentalement ce que je fais:

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

Puis-je aller pour:

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

et bien sûr - tout cela est fait dans votre fichier test.