Piszę przypadki testowe dla mojej aplikacji Node.js przy użyciu języka Mocha. Przypadki testowe wymagają klucza API jako dodatkowej opcji lub parametru wejściowego. Klucz API jest prywatny, więc nie chcę umieszczać go bezpośrednio w plikach testowych, ponieważ każdy może go zobaczyć na GitHub. Wiem, że jest kilka opcji dostępnych dla Mocha pod adresem:

http://mochajs.org/#usage

Ale czy jest możliwe włączenie niektórych parametrów, aby umożliwić testerom określenie własnego klucza API do testu w wierszu poleceń? Jak na przykład:

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

Nie sądzę, że sama Mocha obsługuje przekazywanie dodatkowych parametrów do testów, ale możesz użyć zmiennych środowiskowych:

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

I przeczytaj je w swoich plikach testowych:

var key = process.env.KEY;

Spójrz na optimist modułu przez Substack i nconf z flatiron. Wiele moich testów zależy od parametrów zewnętrznych, a moduły Optimist i nconf ułatwiają ładowanie opcji konfiguracyjnych z pliku json

W poleceniu testowym podaj ścieżkę do pliku config.json

polecenie testowe

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

Alternatywny

Innym wzorcem, którego ostatnio używam, jest moduł config . Możesz określić ./config/default.ymlplik do regularnego uruchamiania i ./config/test.ymlplik do testów.

Podczas uruchamiania zestawu testów wyeksportuj NODE_ENV = test, a moduł konfiguracyjny zostanie załadowany test.yml

W Twoim kodzie jest łatwy dostęp do obiektu konfiguracyjnego

var config = require('config')

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

Łatwym sposobem na ustawienie NODE_ENV = test jest uruchomienie testów z plikiem makefile. Uruchom wszystkie testy za pośrednictwem make test. Aby uruchomić pojedynczy test, wykonajmake one NAME=test/unit/sample-test.js

Przykładowy plik 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

Jednym z najłatwiejszych sposobów przekazywania parametrów podobnych do metody process.argv [index] wspomnianej w tym wątku jest użycie zmiennych konfiguracyjnych npm. Pozwala to nieco wyraźniej zobaczyć nazwę zmiennej:

polecenie testowe:

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"

Pozostałe odpowiedzi są ograniczone, ponieważ nie obsługują wykonywania kodu przed uruchomieniem zestawu testów. Obsługują tylko przekazywanie parametrów.

Ta odpowiedź obsługuje wykonanie kodu PRZED wykonaniem zestawu testów i jest w pełni udokumentowana przez mokkę

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

create ./test/mocha.opts

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

create ./server.bootstrap.js

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

create ./test/test.bootstrap.js

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

wreszcie w twoim server.js:

require('./server.bootstrap');

GOTOWE!

Kod w bootstrapie serwera zostanie wykonany przed testowaniem i uruchomieniem serwera (npm start i npm test)

Kod w bootstrapie testowym zostanie wykonany tylko przed testowaniem (test npm)

Podziękowania dla @damianfabian za to - zobacz Jak zainicjować zmienną globalną w testach jednostkowych?

Nie ma obsługiwanego sposobu, aby to zrobić z Mocha. sugerowanym sposobem jest użycie pliku (na przykład config.json), wymaganie go i pozwolenie innym osobom na zmianę.

To powiedziawszy, jeśli przekażesz klucz na końcu wiersza poleceń (po pliku do przetestowania) i użyjesz - powinien być dostępny za pomocą process.argv (jeśli nie używasz - lub nie jest po zwykłym pliku imię, wtedy mokka zawiedzie).

jeśli uruchomisz ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKey, a test.js zawiera kod:

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

test powinien przejść pomyślnie

Możesz przekazać argument do skryptu testowego mocha za pomocą modułu „minimist”. Zainstaluj za pomocąnpm install minimist

Terminal:

mocha test.js --config=VALUE

Skrypt węzła mokka:

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

Prosty sposób, używając process.argv, który zawiera argumenty wiersza poleceń

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

Później możesz uzyskać YOUR_VALUEswój kod:

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)

Aby zobaczyć wszystko process.argv:

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

Wynik:

$ 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

Mogę wysłać parametr myślący o mochaStream (require ('spawn-mocha-parallel'). MochaStream).

lubić:

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

Wewnątrz pliku ..spec.js

var yourParam = process.env.yourParam;

Czytałem całkiem sporo odpowiedzi, większość z nich była bardziej złożona niż musi być w rzeczywistości.

Powiedzmy, że mam config.ymllub config.json. W moim przypadku jest to plik YAML.

Przede wszystkim instaluję yamljszależność. Posiada funkcję o nazwie load.

Zasadniczo to, co robię:

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

Następnie idę na:

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

I oczywiście - wszystko to jest zrobione w pliku testowym.

jeśli debugujesz / testujesz za pomocą paska bocznego Mocha (rozszerzenie VS Code), po prostu umieść to:

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

w .vscode/settings.json