Ich schreibe Testfälle für meine Node.js-Anwendung mit Mocha. Die Testfälle benötigen einen API-Schlüssel als zusätzliche Eingabeoption oder Parameter. Der API-Schlüssel ist privat, daher möchte ich ihn nicht direkt in die Testdateien aufnehmen, da jeder ihn dann auf GitHub sehen kann. Ich weiß, dass es für Mokka einige Optionen gibt:

http://mochajs.org/#usage

Aber ist es möglich, einige Parameter einzuschließen, damit Tester ihren eigenen API-Schlüssel für den Test in der Befehlszeile angeben können? Sowie:

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

Ich glaube nicht, dass Mocha selbst die Übergabe zusätzlicher Parameter an Ihre Tests unterstützt, aber Sie könnten Umgebungsvariablen verwenden:

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

Und lesen Sie sie in Ihren Testdateien:

var key = process.env.KEY;

Schauen Sie sich das Optimistenmodul von Substack und nconf von flatiron an. Viele meiner Tests hängen von externen Parametern ab, und die Module optimist und nconf erleichtern das Laden von Konfigurationsoptionen aus einer JSON-Datei

Übergeben Sie in Ihrem Testbefehl den Pfad zur Datei config.json

Testbefehl

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

Ein anderes Muster, das ich kürzlich verwendet habe, ist das Konfigurationsmodul . Sie können eine ./config/default.ymlDatei für die regelmäßige Ausführung und eine ./config/test.ymlDatei für Tests angeben .

Wenn Sie Ihre Testsuite ausführen, exportieren Sie NODE_ENV = test und das Konfigurationsmodul wird geladen test.yml

In Ihrem Code ist es einfach, auf das Konfigurationsobjekt zuzugreifen

var config = require('config')

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

Eine einfache Möglichkeit, NODE_ENV = test zu setzen, besteht darin, Ihre Tests mit einem Makefile auszuführen. Führen Sie alle Ihre Tests über aus make test. Um einen einzelnen Test auszuführen, führen Sie ihn ausmake one NAME=test/unit/sample-test.js

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

Eine der einfachsten Möglichkeiten, Parameter zu übergeben, die der in diesem Thread erwähnten Methode process.argv [index] ähneln, ist die Verwendung der Konfigurationsvariablen npm. Auf diese Weise können Sie den Variablennamen etwas deutlicher sehen:

Testbefehl:

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"

Die anderen Antworten sind insofern eingeschränkt, als sie die Codeausführung vor dem Ausführen Ihrer Testsuite nicht unterstützen. Sie unterstützen nur die Übergabe von Parametern.

Diese Antwort unterstützt die Codeausführung, BEVOR Ihre Testsuite ausgeführt wird und vollständig von Mocha dokumentiert wird

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

Erstellen Sie ./test/mocha.opts

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

Erstellen Sie ./server.bootstrap.js

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

Erstellen Sie ./test/test.bootstrap.js

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

endlich in deiner server.js:

require('./server.bootstrap');

GETAN!

Der Code im Server-Bootstrap wird vor dem Testen und der Serverausführung ausgeführt (npm start und npm test).

Der Code im Test-Bootstrap wird nur vor dem Test ausgeführt (npm-Test).

Vielen Dank an @damianfabian für diesen einen - siehe Wie initialisiere ich eine globale Variable in Unit-Testläufen?

Es gibt keine unterstützte Möglichkeit, dies mit Mokka zu tun. Die vorgeschlagene Methode besteht darin, eine Datei (z. B. config.json) zu verwenden, sie zu benötigen und von anderen Personen ändern zu lassen.

Wenn Sie Ihren Schlüssel jedoch am Ende der Befehlszeile (nach der zu testenden Datei) übergeben und verwenden, sollte er mit process.argv verfügbar sein (wenn Sie ihn nicht verwenden - oder nicht nach einer regulären Datei Name, dann wird Mokka versagen).

Wenn Sie ausführen ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKeyund test.js den folgenden Code enthält:

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

Der Test sollte bestehen

Sie können ein Argument mit dem Modul 'minimist' an das Mokka-Testskript übergeben. Installieren mitnpm install minimist

Terminal:

mocha test.js --config=VALUE

Mokka-Knotenskript:

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

Eine einfache Möglichkeit, process.argv zu verwenden, die die Befehlszeilenargumente enthält

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

Später können Sie YOUR_VALUEIhren Code eingeben:

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)

Um alle zu sehen process.argv:

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

Ausgabe:

$ 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

Ich könnte Parameter Gedanken mochaStream senden (erfordern ('spawn-mocha-parallel'). MochaStream).

mögen:

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

In der Datei ..spec.js

var yourParam = process.env.yourParam;

Ich habe einige Antworten gelesen, von denen die meisten komplexer sind, als die eigentliche Lösung sein muss.

Nehmen wir an, ich habe config.ymloder config.json. In meinem Fall ist es eine YAML-Datei.

Zunächst installiere ich die yamljsAbhängigkeit. Es hat eine Funktion namens load.

Grundsätzlich was ich mache:

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

Dann gehe ich für:

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

Und natürlich - das alles geschieht in Ihrer Testdatei.

Wenn Sie mit der Mocha-Seitenleiste (VS-Code-Erweiterung) debuggen / testen, geben Sie einfach Folgendes ein:

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

beim .vscode/settings.json