अतिरिक्त विकल्पों या मापदंडों के साथ मोचा परीक्षण

Question

मैं मोचा का उपयोग करके अपने Node.js एप्लिकेशन के लिए परीक्षण मामले लिख रहा हूं। परीक्षण मामलों को अतिरिक्त इनपुट विकल्प या पैरामीटर के रूप में एक एपीआई कुंजी की आवश्यकता होती है। एपीआई कुंजी निजी है, इसलिए मैं इसे सीधे परीक्षण फाइलों में शामिल नहीं करना चाहता, क्योंकि हर कोई इसे GitHub पर देख सकता है। मुझे पता है कि मोचा के लिए कुछ विकल्प उपलब्ध हैं:

http://mochajs.org/#usage

लेकिन क्या कमांडलाइन में परीक्षण के लिए परीक्षकों को अपनी स्वयं की एपीआई कुंजी निर्दिष्ट करने देने के लिए कुछ मापदंडों को शामिल करना संभव है? जैसे कि:

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

Answer 1

मुझे नहीं लगता कि मोचा स्वयं आपके परीक्षणों के लिए अतिरिक्त मापदंडों को पारित करने का समर्थन करता है, लेकिन आप पर्यावरण चर का उपयोग कर सकते हैं:

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

और उन्हें अपनी परीक्षण फ़ाइलों में पढ़ें:

var key = process.env.KEY;

Comments

कई मापदंडों के लिएenv KEY1=YOUR_KEY1 KEY2=YOUR_KEY2 mocha test

— Philiiiiiipp

2017 में यह अब संभव है, नीचे मेरा जवाब देखें

— danday74

@ danday74 समस्या संवेदनशील जानकारी साझा नहीं कर रही है। मैं यह नहीं देखता कि आपका समाधान उसके आसपास कैसे काम करता है, क्योंकि इसका मतलब है कि कुछ फ़ाइलों को अभी भी चेक नहीं किया जा सकता है। कमांड लाइन पर पारित पर्यावरण चर का उपयोग करके ऐसा करने से रोकता है।

— रॉबर्टबेल्प

Answer 2

पर एक नजर डालें आशावादी Substack द्वारा मॉड्यूल और nconf Flatiron से। मेरे बहुत सारे परीक्षण बाहरी मापदंडों पर निर्भर करते हैं और आशावादी और nconf मॉड्यूल एक json फ़ाइल से कॉन्फ़िगरेशन विकल्प लोड करना आसान बनाता है

अपने परीक्षण कमांड में config.json फ़ाइल का पथ पास करें

परीक्षण आदेश

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

---

विकल्प

एक और पैटर्न जो मैं हाल ही में उपयोग कर रहा हूं वह है कॉन्फ़िगर मॉड्यूल। आप ./config/default.ymlनियमित रूप से चलाने के लिए एक ./config/test.ymlफ़ाइल और परीक्षणों के लिए एक फ़ाइल निर्दिष्ट कर सकते हैं ।

अपना परीक्षण सूट चलाते समय, NODE_ENV = परीक्षण निर्यात करें और कॉन्फ़िगरेशन मॉड्यूल लोड होगा test.yml

आपके कोड में कॉन्फ़िगरेशन ऑब्जेक्ट को एक्सेस करना आसान है

var config = require('config')

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

NODE_ENV = परीक्षण सेट करने का एक आसान तरीका है अपने परीक्षण को मेकफाइल के साथ चलाना। के माध्यम से अपने सभी परीक्षण चलाएं make test। एकल परीक्षण निष्पादित करने के लिए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

Answer 3

इस थ्रेड में उल्लिखित process.argv [index] विधि के समान पैरामीटर पास करने के सबसे आसान तरीकों में से एक npm कॉन्फिग चर का उपयोग कर रहा है। यह आपको चर नाम को थोड़ा और स्पष्ट रूप से देखने की अनुमति देता है:

परीक्षण आदेश:

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"

Comments

यह समाधान npm सुविधा का उपयोग करते हुए काफी अच्छा लगता है। क्या आप इस पर टिप्पणी कर सकते हैं कि आप इस तरह कमांड लाइन से कई तर्क कैसे पारित कर सकते हैं?

— रोमेन

@roman: आप के npm ---somevar=myval --anothervar = anotherVal run mytestसाथ की कोशिश की है process.env.npm_config_somevarऔर process.env.npm_config_anothervar?

— ब्रेट ज़मीर

Answer 4

अन्य उत्तर सीमित हैं कि वे आपके परीक्षण सूट को चलाने से पहले कोड निष्पादन का समर्थन नहीं करते हैं। वे केवल पासिंग मापदंडों का समर्थन करते हैं।

यह उत्तर कोड निष्पादन का समर्थन करता है इससे पहले कि आपका परीक्षण सूट निष्पादित हो और मोचा द्वारा पूरी तरह से प्रलेखित हो

मोचा डॉक्स: 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

अंत में आपके server.js में:

require('./server.bootstrap');

किया हुआ!

सर्वर बूटस्ट्रैप में कोड परीक्षण और सर्वर निष्पादन (npm शुरू और npm परीक्षण) से पहले निष्पादित किया जाएगा।

परीक्षण बूटस्ट्रैप में कोड केवल परीक्षण से पहले निष्पादित किया जाएगा (npm परीक्षण)

इसके लिए @damianfabian को धन्यवाद - देखें कि यूनिट टेस्ट रन में वैश्विक चर को कैसे इनिशियलाइज़ किया जाए?

Answer 5

मोचा के साथ ऐसा करने का कोई समर्थित तरीका नहीं है। सुझाया गया तरीका एक फ़ाइल का उपयोग करना है (उदाहरण के लिए config.json), इसकी आवश्यकता है, और अन्य लोगों को इसे बदलने दें।

कहा जा रहा है, यदि आप कमांडलाइन के अंत में अपनी कुंजी को पास करते हैं (परीक्षण के लिए फ़ाइल के बाद) और उपयोग करते हैं - यह प्रक्रिया का उपयोग करके उपलब्ध होना चाहिए। आरजीवीवी (यदि आप उपयोग नहीं करते हैं - या यह एक नियमित फ़ाइल के बाद नहीं है नाम, तो मोचा विफल हो जाएगा)।

यदि आप चलाते हैं ./node_modules/mocha/bin/mocha --reporter spec test.js --apiKey=someKey, और test.js में कोड होता है:

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

परीक्षा पास होनी चाहिए

Answer 6

आप 'न्यूनतम' मॉड्यूल का उपयोग करके परीक्षण स्क्रिप्ट पर एक तर्क पारित कर सकते हैं। के साथ स्थापित करेंnpm install minimist

टर्मिनल:

mocha test.js --config=VALUE

मोचा नोड स्क्रिप्ट:

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

Answer 7

एक सरल तरीका है, जो process.argv का उपयोग करके कमांड लाइन आर्ग को समाहित करता है

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

बाद में, आप YOUR_VALUEअपने कोड में प्राप्त कर सकते हैं :

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)

सभी को देखने के लिए process.argv:

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

आउटपुट:

$ 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

Comments

क्या यहां के लोगों के लिए इसे समझना आसान नहीं होगा यदि आप इसके mocha -w test/*.js --KEY=YOUR_VALUEबजाय इसे कहते हैं --KEY=YOUR_KEY?

— ndsvw

Answer 8

मैं पैरामीटर सोचा मोचस्ट्रीम (आवश्यकता ('स्पॉन-मोचा-समानांतर') भेज सकता हूं। मोचास्ट्रीम)।

पसंद:

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

अंदर ..spec.js फ़ाइल

var yourParam = process.env.yourParam;

Answer 9

मैं काफी कुछ उत्तर पढ़ रहा हूं, उनमें से अधिकांश वास्तविक समाधान की तुलना में अधिक जटिल हैं।

मान लीजिए कि मेरे पास है config.ymlयाconfig.json । मेरे मामले में यह एक YAML फ़ाइल है।

सबसे पहले मैं yamljsनिर्भरता स्थापित करता हूं । इसका एक फंक्शन होता हैload ।

मूल रूप से मैं क्या करता हूं:

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

फिर मैं जाता हूं:

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

और निश्चित रूप से - यह सब आपकी परीक्षण फ़ाइल में किया जाता है।

Answer 10

यदि आप मोचा साइडबार (वीएस कोड एक्सटेंशन) के साथ डिबगिंग / परीक्षण कर रहे हैं, तो बस इसे डालें:

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

पर .vscode/settings.json

Comments

यह समाधान भी एक विशिष्ट उपकरण से बंधा हुआ है।

— मैटसीजी

हां, मुझे लगता है कि जब मैं उत्तर की शुरुआत में सशर्त लगाता हूं, तो मैं स्पष्ट हूं कि मैं मुख्य संदर्भ के बारे में पूरक / अन्य विकल्प दे रहा हूं। :)

— fsilva