Testy mokka z dodatkowymi opcjami lub parametrami

85

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
afterglowlee
źródło

Odpowiedzi:

86

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;
robertklep
źródło
11
Dla wielu parametrówenv KEY1=YOUR_KEY1 KEY2=YOUR_KEY2 mocha test
Philiiiiiipp,
w 2017 jest to już możliwe, zobacz moją odpowiedź poniżej
danday74
2
@ danday74 problem nie polega na udostępnianiu poufnych informacji. Nie rozumiem, jak to rozwiązanie działa, ponieważ oznacza to, że niektórych plików nadal nie można zarejestrować. Korzystanie ze zmiennych środowiskowych przekazywanych w wierszu poleceń zapobiega takiej konieczności.
robertklep
30

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
Noe
źródło
28

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"
Adam Levine
źródło
to rozwiązanie wydaje się całkiem przyjemne, ponieważ korzysta z obiektu npm. czy mógłbyś skomentować, w jaki sposób możesz przekazać wiele argumentów z wiersza poleceń w ten sposób?
roman
@roman: Czy próbowałeś npm ---somevar=myval --anothervar = anotherVal run mytestz process.env.npm_config_somevari process.env.npm_config_anothervar?
Brett Zamir
26

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?

danday74
źródło
20

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

Alon Bar David
źródło
15

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);
David Douglas
źródło
6

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
Pablo Ezequiel Inchausti
źródło
1
Czy nie byłoby łatwiej zrozumieć ludzi tutaj, gdybyś to nazwał mocha -w test/*.js --KEY=YOUR_VALUEzamiast --KEY=YOUR_KEY?
ndsvw
3

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;
SM Adnan
źródło
2

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.

Bilger Yahov
źródło
0

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

fsilva
źródło
To rozwiązanie jest zbyt powiązane z konkretnym narzędziem.
MattiSG
Tak, myślę, że jestem jasny, kiedy stawiam warunkową odpowiedź na początku, podaję tylko uzupełnienie / inne opcje dotyczące głównego odniesienia. :)
fsilva