@opstarts/chimp
Version:
Develop acceptance tests & end-to-end tests with realtime feedback.
1,599 lines (1,328 loc) • 1.12 MB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Cucumber = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
function Cucumber(featureSource, supportCodeInitializer, options) {
var configuration = Cucumber.VolatileConfiguration(featureSource, supportCodeInitializer, options);
var runtime = Cucumber.Runtime(configuration);
return runtime;
}
Cucumber.Api = require('./cucumber/api');
Cucumber.Ast = require('./cucumber/ast');
Cucumber.Cli = require('./cucumber/cli');
Cucumber.Debug = require('./cucumber/debug'); // Untested namespace
Cucumber.Events = require('./cucumber/events');
Cucumber.Listener = require('./cucumber/listener');
Cucumber.Parser = require('./cucumber/parser');
Cucumber.Runtime = require('./cucumber/runtime');
Cucumber.Status = require('./cucumber/status');
Cucumber.SupportCode = require('./cucumber/support_code');
Cucumber.TagGroupParser = require('./cucumber/tag_group_parser');
Cucumber.Type = require('./cucumber/type');
Cucumber.Util = require('./cucumber/util');
Cucumber.VolatileConfiguration = require('./cucumber/volatile_configuration');
Cucumber.VERSION = require('../package.json').version;
module.exports = Cucumber;
},{"../package.json":181,"./cucumber/api":2,"./cucumber/ast":4,"./cucumber/cli":17,"./cucumber/debug":25,"./cucumber/events":27,"./cucumber/listener":28,"./cucumber/parser":36,"./cucumber/runtime":37,"./cucumber/status":47,"./cucumber/support_code":48,"./cucumber/tag_group_parser":54,"./cucumber/type":55,"./cucumber/util":58,"./cucumber/volatile_configuration":67}],2:[function(require,module,exports){
var Api = {};
Api.Scenario = require('./api/scenario');
module.exports = Api;
},{"./api/scenario":3}],3:[function(require,module,exports){
(function (Buffer){
function Scenario(astScenario, scenarioResult) {
var Cucumber = require('../../cucumber');
var attachments = [];
function isStream(value) {
return value && typeof value === 'object' && typeof value.pipe === 'function';
}
function attachData(data, mimeType) {
var attachment = Cucumber.Runtime.Attachment({mimeType: mimeType, data: data});
attachments.push(attachment);
}
function attachStream(stream, mimeType, callback) {
var buffers = [];
stream.on('data', function (chunk) {
buffers.push(chunk);
});
stream.on('end', function () {
attachData(Buffer.concat(buffers), mimeType);
callback();
});
}
var self = {
getKeyword: function getKeyword() { return astScenario.getKeyword(); },
getName: function getName() { return astScenario.getName(); },
getDescription: function getDescription() { return astScenario.getDescription(); },
getUri: function getUri() { return astScenario.getUri(); },
getLine: function getLine() { return astScenario.getLine(); },
getTags: function getTags() { return astScenario.getTags(); },
isSuccessful: function isSuccessful() { return scenarioResult.getStatus() === Cucumber.Status.PASSED; },
isFailed: function isFailed() { return scenarioResult.getStatus() === Cucumber.Status.FAILED; },
isPending: function isPending() { return scenarioResult.getStatus() === Cucumber.Status.PENDING; },
isUndefined: function isUndefined() { return scenarioResult.getStatus() === Cucumber.Status.UNDEFINED; },
isSkipped: function isSkipped() { return scenarioResult.getStatus() === Cucumber.Status.SKIPPED; },
getException: function getException() { return scenarioResult.getFailureException(); },
getAttachments: function getAttachments() { return attachments; },
clearAttachments: function clearAttachments() { attachments = []; },
attach: function attach(data, mimeType, callback) {
if (isStream(data)) {
if (!mimeType)
throw Error(Scenario.ATTACH_MISSING_MIME_TYPE_ARGUMENT);
if (!callback)
throw Error(Scenario.ATTACH_MISSING_CALLBACK_ARGUMENT_FOR_STREAM_READABLE);
attachStream(data, mimeType, callback);
}
else if (Buffer && Buffer.isBuffer(data)) {
if (!mimeType)
throw Error(Scenario.ATTACH_MISSING_MIME_TYPE_ARGUMENT);
attachData(data, mimeType);
if (callback) callback();
}
else if (typeof(data) === 'string') {
if (!mimeType)
mimeType = Scenario.DEFAULT_TEXT_MIME_TYPE;
attachData(data, mimeType);
if (callback) callback();
} else {
throw Error(Scenario.ATTACH_INVALID_DATA_TYPE);
}
}
};
return self;
}
Scenario.DEFAULT_TEXT_MIME_TYPE = 'text/plain';
Scenario.ATTACH_MISSING_MIME_TYPE_ARGUMENT = 'Cucumber.Api.Scenario.attach() expects a mimeType';
Scenario.ATTACH_MISSING_CALLBACK_ARGUMENT_FOR_STREAM_READABLE = 'Cucumber.Api.Scenario.attach() expects a callback when data is a stream.Readable';
Scenario.ATTACH_INVALID_DATA_TYPE = 'Cucumber.Api.Scenario.attach() expects data to be a stream, buffer, or string.';
module.exports = Scenario;
}).call(this,require("buffer").Buffer)
},{"../../cucumber":1,"buffer":73}],4:[function(require,module,exports){
var Ast = {};
Ast.DataTable = require('./ast/data_table');
Ast.DocString = require('./ast/doc_string');
Ast.Feature = require('./ast/feature');
Ast.Filter = require('./ast/filter');
Ast.Scenario = require('./ast/scenario');
Ast.Step = require('./ast/step');
Ast.HookStep = require('./ast/hook_step');
Ast.Tag = require('./ast/tag');
module.exports = Ast;
},{"./ast/data_table":5,"./ast/doc_string":6,"./ast/feature":7,"./ast/filter":8,"./ast/hook_step":13,"./ast/scenario":14,"./ast/step":15,"./ast/tag":16}],5:[function(require,module,exports){
function DataTable(data) {
var Cucumber = require('../../cucumber');
var _ = require('lodash');
var rawTable = data.rows.map(function (row) {
return row.cells.map(function (cell) {
return cell.value;
});
});
var self = {
getType: function getType() {
return 'DataTable';
},
rows: function rows() {
var copy = self.raw();
copy.shift();
return copy;
},
rowsHash: function rowsHash() {
var rows = self.raw();
var everyRowHasTwoColumns = rows.every(function (row) {
return row.length === 2;
});
if (!everyRowHasTwoColumns) {
throw new Error('rowsHash was called on a data table with more than two columns');
}
return _.fromPairs(rows);
},
raw: function raw() {
return rawTable.slice(0);
},
hashes: function hashes() {
var raw = self.raw();
var hashDataTable = Cucumber.Type.HashDataTable(raw);
var rawHashDataTable = hashDataTable.raw();
return rawHashDataTable;
}
};
return self;
}
module.exports = DataTable;
},{"../../cucumber":1,"lodash":156}],6:[function(require,module,exports){
function DocString(data) {
var self = {
getType: function getType() {
return 'DocString';
},
getContent: function getContent() {
return data.content;
},
getContentType: function getContentType() {
return data.contentType;
},
getLine: function getLine() {
return data.location.line;
}
};
return self;
}
module.exports = DocString;
},{}],7:[function(require,module,exports){
function Feature(data, scenarios) {
var Cucumber = require('../../cucumber');
var Gherkin = require('gherkin');
var _ = require('lodash');
var tags = [];
if (data.tags) {
tags = data.tags.map(function (tagData) {
return Cucumber.Ast.Tag(tagData);
});
}
var self = {
getStepKeywordByLines: function getStepKeywordByLines(lines) {
var steps = _.flatten(_.map(data.children, 'steps'));
var step = _.find(steps, function(node) {
return _.includes(lines, node.location.line);
});
if (step) {
return step.keyword;
}
},
getScenarioKeyword: function() {
return Gherkin.DIALECTS[self.getLanguage()].scenario;
},
getKeyword: function getKeyword() {
return data.keyword;
},
getLanguage: function getKeyword() {
return data.language;
},
getName: function getName() {
return data.name;
},
getDescription: function getDescription() {
return data.description;
},
getUri: function getUri() {
return data.uri;
},
getLine: function getLine() {
return data.location.line;
},
getTags: function getTags() {
return tags;
},
getScenarios: function getScenarios() {
return scenarios;
}
};
scenarios.forEach(function(scenario) {
scenario.setFeature(self);
});
return self;
}
module.exports = Feature;
},{"../../cucumber":1,"gherkin":136,"lodash":156}],8:[function(require,module,exports){
var _ = require('lodash');
function Filter(rules) {
var self = {
isElementEnrolled: function isElementEnrolled(element) {
var enrolled = _.every(rules, function (rule) {
return rule.isSatisfiedByElement(element);
});
return enrolled;
}
};
return self;
}
Filter.AnyOfTagsRule = require('./filter/any_of_tags_rule');
Filter.AnyOfNamesRule = require('./filter/any_of_names_rule');
Filter.ElementMatchingTagSpec = require('./filter/element_matching_tag_spec');
Filter.ScenarioAtLineRule = require('./filter/scenario_at_line_rule');
module.exports = Filter;
},{"./filter/any_of_names_rule":9,"./filter/any_of_tags_rule":10,"./filter/element_matching_tag_spec":11,"./filter/scenario_at_line_rule":12,"lodash":156}],9:[function(require,module,exports){
var _ = require('lodash');
function AnyOfNamesRule(names) {
var self = {
isSatisfiedByElement: function isSatisfiedByElement(element) {
if (names.length === 0) {
return true;
}
var satisfied = _.some(names, function (name) {
return element.getName().match(name);
});
return satisfied;
}
};
return self;
}
module.exports = AnyOfNamesRule;
},{"lodash":156}],10:[function(require,module,exports){
var _ = require('lodash');
function AnyOfTagsRule(tags) {
var Cucumber = require('../../../cucumber');
var self = {
isSatisfiedByElement: function isSatisfiedByElement(element) {
var satisfied = _.some(tags, function (tag) {
var spec = Cucumber.Ast.Filter.ElementMatchingTagSpec(tag);
return spec.isMatching(element);
});
return satisfied;
}
};
return self;
}
module.exports = AnyOfTagsRule;
},{"../../../cucumber":1,"lodash":156}],11:[function(require,module,exports){
var _ = require('lodash');
function ElementMatchingTagSpec(tagName) {
var self = {
isMatching: function isMatching(element) {
var elementTags = element.getTags();
var matching;
if (self.isExpectingTag())
matching = _.some(elementTags, self.isTagSatisfying);
else
matching = _.every(elementTags, self.isTagSatisfying);
return matching;
},
isTagSatisfying: function isTagSatisfying(tag) {
var checkedTagName = tag.getName();
var satisfying;
if (self.isExpectingTag())
satisfying = checkedTagName === tagName;
else {
var negatedCheckedTagName = ElementMatchingTagSpec.NEGATION_CHARACTER + checkedTagName;
satisfying = negatedCheckedTagName !== tagName;
}
return satisfying;
},
isExpectingTag: function isExpectingTag() {
var expectingTag = tagName[0] !== ElementMatchingTagSpec.NEGATION_CHARACTER;
return expectingTag;
}
};
return self;
}
ElementMatchingTagSpec.NEGATION_CHARACTER = '~';
module.exports = ElementMatchingTagSpec;
},{"lodash":156}],12:[function(require,module,exports){
function ScenarioAtLineRule(suppliedPaths) {
var Cucumber = require('../../../cucumber');
var fs = require('fs');
var _ = require('lodash');
var mapping = {};
suppliedPaths.forEach(function(path){
var matches = Cucumber.Cli.Configuration.FEATURE_FILENAME_AND_LINENUM_REGEXP.exec(path);
var specifiedLineNums = matches && matches[2];
if (specifiedLineNums) {
var realPath = fs.realpathSync(matches[1]);
if (!mapping[realPath]) {
mapping[realPath] = [];
}
specifiedLineNums.split(':').forEach(function (lineNum) {
mapping[realPath].push(parseInt(lineNum));
});
}
});
var self = {
isSatisfiedByElement: function isSatisfiedByElement(element) {
if (element.getUri && element.getLines) {
var lines = mapping[element.getUri()];
if (lines) {
return _.some(element.getLines(), function (line) {
return _.includes(lines, line);
});
}
}
return true;
}
};
return self;
}
module.exports = ScenarioAtLineRule;
},{"../../../cucumber":1,"fs":72,"lodash":156}],13:[function(require,module,exports){
function HookStep(keyword) {
var Cucumber = require('../../cucumber');
var self = Cucumber.Ast.Step({});
self.getKeyword = function getKeyword() {
return keyword;
};
self.isHidden = function isHidden() {
return true;
};
self.hasUri = function hasUri() {
return false;
};
return self;
}
HookStep.BEFORE_STEP_KEYWORD = 'Before ';
HookStep.AFTER_STEP_KEYWORD = 'After ';
module.exports = HookStep;
},{"../../cucumber":1}],14:[function(require,module,exports){
function Scenario(data) {
var Cucumber = require('../../cucumber');
var _ = require('lodash');
var feature, steps, tags = [];
var self = {
getName: function getName() {
return data.name;
},
getKeyword: function getKeyword() {
return self.getFeature().getScenarioKeyword();
},
getDescription: function getDescription() {
return data.description;
},
getFeature: function getFeature() {
return feature;
},
setFeature: function setFeature(value) {
feature = value;
},
getUri: function getUri() {
return _.first(self.getUris());
},
getUris: function getUris() {
return _.map(data.locations, 'path');
},
getLine: function getLine() {
return _.first(self.getLines());
},
getLines: function getLines() {
return _.map(data.locations, 'line');
},
getTags: function getTags() {
return tags;
},
getSteps: function getSteps() {
return steps;
}
};
var previousStep;
steps = data.steps.map(function (stepData) {
var step = Cucumber.Ast.Step(stepData);
step.setScenario(self);
step.setPreviousStep(previousStep);
previousStep = step;
return step;
});
if (data.tags) {
tags = data.tags.map(function (tagData) {
return Cucumber.Ast.Tag(tagData);
});
}
return self;
}
module.exports = Scenario;
},{"../../cucumber":1,"lodash":156}],15:[function(require,module,exports){
function Step(data) {
var Cucumber = require('../../cucumber');
var Gherkin = require('gherkin');
var _ = require('lodash');
var previousStep, scenario;
var stepArguments = [];
if (data.arguments) {
stepArguments = data.arguments.map(function (arg) {
if (arg.hasOwnProperty('content')) {
return Cucumber.Ast.DocString(arg);
} else if (arg.hasOwnProperty('rows')) {
return Cucumber.Ast.DataTable(arg);
} else {
throw new Error('Unknown step argument type: ' + JSON.stringify(arg));
}
});
}
var self = {
getScenario: function getScenario() {
return scenario;
},
setScenario: function setScenario(newScenario) {
scenario = newScenario;
},
setPreviousStep: function setPreviousStep(newPreviousStep) {
previousStep = newPreviousStep;
},
isHidden: function isHidden() {
return false;
},
getName: function getName() {
return data.text;
},
getKeyword: function getKeyword() {
return self.getScenario().getFeature().getStepKeywordByLines(self.getLines());
},
hasUri: function hasUri() {
return true;
},
getLine: function getLine() {
return _.last(self.getLines());
},
getLines: function getLines() {
return _.map(data.locations, 'line');
},
getUri: function getUri() {
return _.first(self.getUris());
},
getUris: function getUris() {
return _.map(data.locations, 'path');
},
getPreviousStep: function getPreviousStep() {
return previousStep;
},
hasPreviousStep: function hasPreviousStep() {
return !!previousStep;
},
getArguments: function getArguments() {
return stepArguments;
},
isOutcomeStep: function isOutcomeStep() {
return self.hasOutcomeStepKeyword() || self.isRepeatingOutcomeStep();
},
isEventStep: function isEventStep() {
return self.hasEventStepKeyword() || self.isRepeatingEventStep();
},
hasOutcomeStepKeyword: function hasOutcomeStepKeyword() {
var language = self.getScenario().getFeature().getLanguage();
return _.chain(Gherkin.DIALECTS[language].then)
.includes(self.getKeyword())
.value();
},
hasEventStepKeyword: function hasEventStepKeyword() {
var language = self.getScenario().getFeature().getLanguage();
return _.chain(Gherkin.DIALECTS[language].when)
.includes(self.getKeyword())
.value();
},
isRepeatingOutcomeStep: function isRepeatingOutcomeStep() {
return self.hasRepeatStepKeyword() && self.isPrecededByOutcomeStep();
},
isRepeatingEventStep: function isRepeatingEventStep() {
return self.hasRepeatStepKeyword() && self.isPrecededByEventStep();
},
hasRepeatStepKeyword: function hasRepeatStepKeyword() {
var language = self.getScenario().getFeature().getLanguage();
return _.chain(Gherkin.DIALECTS[language].and)
.concat(Gherkin.DIALECTS[language].but)
.includes(self.getKeyword())
.value();
},
isPrecededByOutcomeStep: function isPrecededByOutcomeStep() {
var result = false;
if (self.hasPreviousStep()) {
var previousStep = self.getPreviousStep();
result = previousStep.isOutcomeStep();
}
return result;
},
isPrecededByEventStep: function isPrecededByEventStep() {
var result = false;
if (self.hasPreviousStep()) {
var previousStep = self.getPreviousStep();
result = previousStep.isEventStep();
}
return result;
}
};
return self;
}
Step.EVENT_STEP_KEYWORD = 'When ';
Step.OUTCOME_STEP_KEYWORD = 'Then ';
Step.AND_STEP_KEYWORD = 'And ';
Step.BUT_STEP_KEYWORD = 'But ';
Step.STAR_STEP_KEYWORD = '* ';
module.exports = Step;
},{"../../cucumber":1,"gherkin":136,"lodash":156}],16:[function(require,module,exports){
function Tag(data) {
var self = {
getName: function getName() {
return data.name;
},
getLine: function getLine() {
return data.location.line;
}
};
return self;
}
module.exports = Tag;
},{}],17:[function(require,module,exports){
function Cli(argv) {
var Cucumber = require('../cucumber');
var Command = require('commander').Command;
var path = require('path');
var _ = require('lodash');
function mergeWorldParametersJson(str, memo) {
var val;
try {
val = JSON.parse(str);
} catch (error) {
throw new Error('--world-parameters passed invalid JSON: ' + error.message + ': ' + str);
}
if (!_.isPlainObject(val)) {
throw new Error('--world-parameters must be passed a JSON string of an object: ' + str);
}
_.merge(memo, val);
return memo;
}
function collect(val, memo) {
memo.push(val);
return memo;
}
function getProgram () {
var program = new Command(path.basename(argv[1]));
program
.usage('[options] [<DIR | FILE[:LINE]>...]')
.version(Cucumber.VERSION, '-v, --version')
.option('-b, --backtrace', 'show full backtrace for errors')
.option('--compiler <EXTENSION:MODULE>', 'require files with the given EXTENSION after requiring MODULE (repeatable)', collect, [])
.option('-d, --dry-run', 'invoke formatters without executing steps')
.option('--fail-fast', 'abort the run on first failure')
.option('-f, --format <TYPE[:PATH]>', 'specify the output format, optionally supply PATH to redirect formatter output (repeatable)', collect, ['pretty'])
.option('--name <REGEXP>', 'only execute the scenarios with name matching the expression (repeatable)', collect, [])
.option('--no-colors', 'disable colors in formatter output')
.option('-p, --profile <NAME>', 'specify the profile to use (repeatable)', collect, [])
.option('-r, --require <FILE | DIR>', 'require files before executing features (repeatable)', collect, [])
.option('--snippet-interface [callback | generator | promise | synchronous]', 'specify a snippet interface', 'callback')
.option('--snippet-syntax [<FILE>]', 'specify a custom snippet syntax')
.option('-S, --strict', 'fail if there are any undefined or pending steps')
.option('-t, --tags <EXPRESSION>', 'only execute the features or scenarios with tags matching the expression (repeatable)', collect, [])
.option('--world-parameters <JSON>', 'provide parameters that will be passed to the world constructor (repeatable)', mergeWorldParametersJson, {});
program.on('--help', function(){
console.log(' For more details please visit https://github.com/cucumber/cucumber-js#cli\n');
});
return program;
}
function getConfiguration() {
var program = getProgram();
program.parse(argv);
var profileArgs = Cucumber.Cli.ProfilesLoader.getArgs(program.profile);
if (profileArgs.length > 0) {
var fullArgs = argv.slice(0, 2).concat(profileArgs).concat(argv.slice(2));
program = getProgram();
program.parse(fullArgs);
}
var configuration = Cucumber.Cli.Configuration(program.opts(), program.args);
return configuration;
}
var self = {
run: function run(callback) {
var configuration = getConfiguration();
var runtime = Cucumber.Runtime(configuration);
var formatters = configuration.getFormatters();
formatters.forEach(function (formatter) {
runtime.attachListener(formatter);
});
runtime.start(callback);
}
};
return self;
}
Cli.Configuration = require('./cli/configuration');
Cli.FeaturePathExpander = require('./cli/feature_path_expander');
Cli.FeatureSourceLoader = require('./cli/feature_source_loader');
Cli.PathExpander = require('./cli/path_expander');
Cli.ProfilesLoader = require('./cli/profiles_loader');
Cli.SupportCodeLoader = require('./cli/support_code_loader');
Cli.SupportCodePathExpander = require('./cli/support_code_path_expander');
module.exports = Cli;
},{"../cucumber":1,"./cli/configuration":18,"./cli/feature_path_expander":19,"./cli/feature_source_loader":20,"./cli/path_expander":21,"./cli/profiles_loader":22,"./cli/support_code_loader":23,"./cli/support_code_path_expander":24,"commander":98,"lodash":156,"path":160}],18:[function(require,module,exports){
(function (process){
function Configuration(options, args) {
var Cucumber = require('../../cucumber');
var path = require('path');
var fs = require('fs');
var _ = require('lodash');
var unexpandedFeaturePaths = ['features'];
if (args.length > 0) {
unexpandedFeaturePaths = [];
args.forEach(function(arg) {
var filename = path.basename(arg);
if (filename[0] === '@') {
var content = fs.readFileSync(arg, 'utf8');
unexpandedFeaturePaths = unexpandedFeaturePaths.concat(content.split('\n'));
} else {
unexpandedFeaturePaths.push(arg);
}
});
}
var expandedFeaturePaths = Cucumber.Cli.FeaturePathExpander.expandPaths(unexpandedFeaturePaths);
function getCompilerExtensions() {
return options.compiler.map(function(compiler) {
return compiler.split(':')[0];
});
}
function getCompilerModules() {
return options.compiler.map(function(compiler) {
return compiler.split(':')[1];
});
}
function getFeatureDirectoryPaths() {
return expandedFeaturePaths.map(function (featurePath) {
return path.dirname(featurePath);
});
}
function getFormats() {
var outputMapping = {};
options.format.forEach(function (format) {
var parts = format.split(':');
var type = parts[0];
var outputTo = parts.slice(1).join(':');
outputMapping[outputTo] = type;
});
return _.map(outputMapping, function (type, outputTo) {
var stream = process.stdout;
if (outputTo) {
var fd = fs.openSync(outputTo, 'w');
stream = fs.createWriteStream(null, {fd: fd});
}
return {stream: stream, type: type};
});
}
function getSnippetSyntax () {
var builder = Cucumber.SupportCode.StepDefinitionSnippetBuilder.JavaScriptSyntax;
if (options.snippetSyntax) {
var snippetSyntaxPath = path.resolve(process.cwd(), options.snippetSyntax);
builder = require(snippetSyntaxPath);
}
return builder(options.snippetInterface);
}
function getSupportCodePaths() {
var unexpandedSupportCodePaths = options.require.length > 0 ? options.require : getFeatureDirectoryPaths();
var extensions = ['js'].concat(getCompilerExtensions());
return Cucumber.Cli.SupportCodePathExpander.expandPaths(unexpandedSupportCodePaths, extensions);
}
var self = {
getFormatters: function getFormatters() {
var formats = getFormats();
var snippetSyntax = getSnippetSyntax();
var formatters = formats.map(function (format) {
var formatterOptions = {
snippetSyntax: snippetSyntax,
stream: format.stream,
useColors: options.colors
};
switch(format.type) {
case 'json':
return Cucumber.Listener.JsonFormatter(formatterOptions);
case 'progress':
return Cucumber.Listener.ProgressFormatter(formatterOptions);
case 'pretty':
return Cucumber.Listener.PrettyFormatter(formatterOptions);
case 'snippets':
return Cucumber.Listener.SnippetsFormatter(formatterOptions);
case 'summary':
return Cucumber.Listener.SummaryFormatter(formatterOptions);
case 'rerun':
return Cucumber.Listener.RerunFormatter(formatterOptions);
default:
throw new Error('Unknown formatter name "' + format.type + '".');
}
});
return formatters;
},
getFeatureSources: function getFeatureSources() {
var featureSourceLoader = Cucumber.Cli.FeatureSourceLoader(expandedFeaturePaths);
return featureSourceLoader.getSources();
},
getAstFilter: function getAstFilter() {
var tagGroups = Cucumber.TagGroupParser.getTagGroupsFromStrings(options.tags);
var tagRules = tagGroups.map(function (tags) {
return Cucumber.Ast.Filter.AnyOfTagsRule(tags);
});
var lineRule = Cucumber.Ast.Filter.ScenarioAtLineRule(unexpandedFeaturePaths);
var nameRule = Cucumber.Ast.Filter.AnyOfNamesRule(options.name);
var rules = tagRules.concat([lineRule, nameRule]);
return Cucumber.Ast.Filter(rules);
},
getSupportCodeLibrary: function getSupportCodeLibrary() {
var supportCodePaths = getSupportCodePaths();
var compilerModules = getCompilerModules();
var supportCodeLoader = Cucumber.Cli.SupportCodeLoader(supportCodePaths, compilerModules);
return supportCodeLoader.getSupportCodeLibrary();
},
getWorldParameters: function getWorldParameters() {
return options.worldParameters;
},
isFailFastRequested: function isFailFastRequested() {
return options.failFast;
},
isDryRunRequested: function isDryRunRequested() {
return options.dryRun;
},
isStrictRequested: function isStrictRequested() {
return options.strict;
},
shouldFilterStackTraces: function shouldFilterStackTraces() {
return !options.backtrace;
}
};
return self;
}
Configuration.FEATURE_FILENAME_AND_LINENUM_REGEXP = /([^\:]*)((?::[\d]+)+)?/;
module.exports = Configuration;
}).call(this,require('_process'))
},{"../../cucumber":1,"_process":162,"fs":72,"lodash":156,"path":160}],19:[function(require,module,exports){
var FeaturePathExpander = {
expandPaths: function expandPaths(paths) {
var Cucumber = require('../../cucumber');
var PathExpander = Cucumber.Cli.PathExpander;
paths = paths.map(function(path) {
return path.replace(/(:\d+)*$/g, ''); // Strip line numbers
});
var expandedPaths = PathExpander.expandPathsWithExtensions(paths, ['feature']);
return expandedPaths;
}
};
module.exports = FeaturePathExpander;
},{"../../cucumber":1}],20:[function(require,module,exports){
function FeatureSourceLoader(featureFilePaths) {
var fs = require('fs');
var self = {
getSources: function getSources() {
var sources = [];
featureFilePaths.forEach(function (featureFilePath) {
var source = fs.readFileSync(featureFilePath, 'utf8');
sources.push([featureFilePath, source]);
});
return sources;
}
};
return self;
}
module.exports = FeatureSourceLoader;
},{"fs":72}],21:[function(require,module,exports){
var fs = require('fs');
var glob = require('glob');
var _ = require('lodash');
var PathExpander = {
expandPathsWithExtensions: function expandPathsWithExtensions(paths, extensions) {
var expandedPaths = paths.map(function (path) {
return PathExpander.expandPathWithExtensions(path, extensions);
});
return _.uniq(_.flatten(expandedPaths));
},
expandPathWithExtensions: function expandPathWithExtensions(path, extensions) {
var realPath = fs.realpathSync(path);
var stats = fs.statSync(realPath);
if (stats.isDirectory()) {
return this.expandDirectoryWithExtensions(realPath, extensions);
} else {
return [realPath];
}
},
expandDirectoryWithExtensions: function expandDirectoryWithExtensions(realPath, extensions) {
var pattern = realPath + '/**/*.';
if (extensions.length > 1) {
pattern += '{' + extensions.join(',') + '}';
} else {
pattern += extensions[0];
}
return glob.sync(pattern);
}
};
module.exports = PathExpander;
},{"fs":72,"glob":150,"lodash":156}],22:[function(require,module,exports){
(function (process){
var fs = require('fs');
var path = require('path');
var _ = require('lodash');
function getDefinitions () {
var definitionFilePath = path.join(process.cwd(), 'cucumber.js');
if (fs.existsSync(definitionFilePath)) {
var definitions = require(definitionFilePath);
if (typeof definitions !== 'object') {
throw new Error(definitionFilePath + ' does not export an object');
}
return definitions;
} else {
return {};
}
}
var ProfilesLoader = {
getArgs: function getArgs (profiles) {
var definitions = getDefinitions();
if (profiles.length === 0 && definitions['default']) {
profiles = ['default'];
}
var profilesArgs = profiles.map(function (profile){
if (!definitions[profile]){
throw new Error('Undefined profile: ' + profile);
}
return definitions[profile].split(/\s/);
});
return _.flatten(profilesArgs);
}
};
module.exports = ProfilesLoader;
}).call(this,require('_process'))
},{"_process":162,"fs":72,"lodash":156,"path":160}],23:[function(require,module,exports){
(function (process){
var os = require('os');
var path = require('path');
function SupportCodeLoader(supportCodeFilePaths, compilerModules) {
var Cucumber = require('../../cucumber');
var self = {
getSupportCodeLibrary: function getSupportCodeLibrary() {
var supportCodeInitialiazer = self.getSupportCodeInitializer();
var supportCodeLibrary = Cucumber.SupportCode.Library(supportCodeInitialiazer);
return supportCodeLibrary;
},
getSupportCodeInitializer: function getSupportCodeInitializer() {
var primeSupportCodeInitializer = self.getPrimeSupportCodeInitializer();
var secondarySupportCodeInitializer = self.getSecondarySupportCodeInitializer();
var initializer = function () {
var supportCodeHelper = this;
var userLandModulesPath = path.join(process.cwd(), 'node_modules');
process.env.NODE_PATH += SupportCodeLoader.ENV_VAR_PATH_SEPARATOR + userLandModulesPath;
require('module').Module._initPaths();
compilerModules.forEach(require);
primeSupportCodeInitializer.call(supportCodeHelper);
secondarySupportCodeInitializer.call(supportCodeHelper);
};
return initializer;
},
getPrimeSupportCodeInitializer: function getPrimeSupportCodeInitializer() {
var primeSupportCodeFilePaths = self.getPrimeSupportCodeFilePaths();
var primeSupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(primeSupportCodeFilePaths);
return primeSupportCodeInitializer;
},
getSecondarySupportCodeInitializer: function getSecondarySupportCodeBlocks() {
var secondarySupportCodeFilePaths = self.getSecondarySupportCodeFilePaths();
var secondarySupportCodeInitializer = self.buildSupportCodeInitializerFromPaths(secondarySupportCodeFilePaths);
return secondarySupportCodeInitializer;
},
getPrimeSupportCodeFilePaths: function getPrimeSupportCodeFilePaths() {
var primeSupportCodeFilePaths = [];
supportCodeFilePaths.forEach(function (path) {
if (path.match(SupportCodeLoader.PRIME_SUPPORT_CODE_PATH_REGEXP))
primeSupportCodeFilePaths.push(path);
});
return primeSupportCodeFilePaths;
},
getSecondarySupportCodeFilePaths: function getSecondarySupportCodeFilePaths() {
var secondarySupportCodeFilePaths = [];
supportCodeFilePaths.forEach(function (path) {
if (!path.match(SupportCodeLoader.PRIME_SUPPORT_CODE_PATH_REGEXP))
secondarySupportCodeFilePaths.push(path);
});
return secondarySupportCodeFilePaths;
},
buildSupportCodeInitializerFromPaths: function buildSupportCodeInitializerFromPaths(paths) {
var wrapper = function () {
var supportCodeHelper = this;
paths.forEach(function (path) {
var initializer = require(path);
if (typeof(initializer) === 'function') {
initializer.call(supportCodeHelper);
} else if (initializer.hasOwnProperty('default') && typeof(initializer.default) === 'function') {
initializer.default.call(supportCodeHelper);
}
});
};
return wrapper;
}
};
return self;
}
SupportCodeLoader.WINDOWS_PLATFORM_REGEXP = /^win/;
SupportCodeLoader.PRIME_SUPPORT_CODE_PATH_REGEXP = os.platform().match(SupportCodeLoader.WINDOWS_PLATFORM_REGEXP) ? /\\support\\/ : /\/support\//i;
SupportCodeLoader.ENV_VAR_PATH_SEPARATOR = os.platform().match(SupportCodeLoader.WINDOWS_PLATFORM_REGEXP) ? ';' : ':';
module.exports = SupportCodeLoader;
}).call(this,require('_process'))
},{"../../cucumber":1,"_process":162,"module":72,"os":159,"path":160}],24:[function(require,module,exports){
var SupportCodePathExpander = {
expandPaths: function expandPaths(paths, extensions) {
var Cucumber = require('../../cucumber');
var PathExpander = Cucumber.Cli.PathExpander;
var expandedPaths = PathExpander.expandPathsWithExtensions(paths, extensions);
return expandedPaths;
}
};
module.exports = SupportCodePathExpander;
},{"../../cucumber":1}],25:[function(require,module,exports){
(function (process){
var Debug = {
TODO: function TODO(description) {
return function () { throw(new Error('IMPLEMENT ME: ' + description)); };
},
warn: function warn(string, caption, level) {
if (Debug.isMessageLeveltoBeDisplayed(level))
process.stdout.write(Debug.warningString(string, caption));
},
notice: function notice(string, caption, level) {
if (Debug.isMessageLeveltoBeDisplayed(level))
process.stdout.write(Debug.noticeString(string, caption));
},
warningString: function warningString(string, caption) {
caption = caption || 'debug-warning';
return '\x1B[30;43m' + caption + ':\x1B[0m[33m' + string + '\x1B[0m';
},
noticeString: function noticeString(string, caption) {
caption = caption || 'debug-notice';
return '\x1B[30;46m' + caption + ':\x1B[0m \x1B[36m' + string + '\x1B[0m';
},
prefix: function prefix() {
return ;
},
isMessageLeveltoBeDisplayed: function isMessageLeveltoBeDisplayed(level) {
if (process.env) {
level = level || 3; // default level
return (level <= process.env.DEBUG_LEVEL);
} else {
return false;
}
}
};
Debug.SimpleAstListener = require('./debug/simple_ast_listener');
module.exports = Debug;
}).call(this,require('_process'))
},{"./debug/simple_ast_listener":26,"_process":162}],26:[function(require,module,exports){
function SimpleAstListener(options) {
var logs = '';
var failed = false;
var beforeEachScenarioCallbacks = [];
var currentFeature, currentStep;
if (!options)
options = {};
function indent(text, indentation) {
var indented;
text.split('\n').forEach(function (line) {
var prefix = new Array(indentation + 1).join(' ');
line = prefix + line;
indented = (typeof(indented) === 'undefined' ? line : indented + '\n' + line);
});
return indented;
}
function log(message, indentation) {
if (indentation)
message = indent(message, indentation);
logs = logs + message + '\n';
if (options.stream)
options.stream.write(message);
if (typeof(options.logToFunction) === 'function')
options.logToFunction (message);
}
var self = {
hear: function hear(event, callback) {
switch(event.getName()) {
case 'BeforeFeature':
self.hearBeforeFeature(event.getPayloadItem('feature'), callback);
break;
case 'BeforeScenario':
self.hearBeforeScenario(event.getPayloadItem('scenario'), callback);
break;
case 'BeforeStep':
self.hearBeforeStep(event.getPayloadItem('step'), callback);
break;
case 'StepResult':
self.hearStepResult(event.getPayloadItem('stepResult'), callback);
break;
default:
callback();
}
},
hearBeforeFeature: function hearBeforeFeature(feature, callback) {
currentFeature = feature;
log('Feature: ' + feature.getName());
var description = feature.getDescription();
if (description !== '')
log(description, 1);
callback();
},
hearBeforeScenario: function hearBeforeScenario(scenario, callback) {
beforeEachScenarioCallbacks.forEach(function (func) {
func();
});
log('');
log(scenario.getName(), 1);
callback();
},
hearBeforeStep: function hearBeforeStep(step, callback) {
currentStep = step;
currentStep =
callback();
},
hearStepResult: function hearStepResult(stepResult, callback) {
log(currentStep.getKeyword() + (currentStep.getName() || ''), 2);
if (currentStep.hasDocString()) {
log('"""', 3);
log(currentStep.getDocString().getContents(), 3);
log('"""', 3);
}
callback();
},
getLogs: function getLogs() {
return logs;
},
featuresPassed: function featuresPassed() {
return !failed;
},
beforeEachScenarioDo: function beforeEachScenarioDo(func) {
beforeEachScenarioCallbacks.push(func);
}
};
return self;
}
module.exports = SimpleAstListener;
},{}],27:[function(require,module,exports){
var _ = require('lodash');
var events = {
FEATURES_EVENT_NAME: 'Features',
FEATURES_RESULT_EVENT_NAME: 'FeaturesResult',
FEATURE_EVENT_NAME: 'Feature',
SCENARIO_EVENT_NAME: 'Scenario',
SCENARIO_RESULT_EVENT_NAME: 'ScenarioResult',
STEP_EVENT_NAME: 'Step',
STEP_RESULT_EVENT_NAME: 'StepResult'
};
var BEFORE_EVENT_NAME_PREFIX = 'Before';
var AFTER_EVENT_NAME_PREFIX = 'After';
function getBeforeEvent(name) {
return BEFORE_EVENT_NAME_PREFIX + name;
}
function getAfterEvent(name) {
return AFTER_EVENT_NAME_PREFIX + name;
}
function getAroundEventsFor(name) {
return [
getBeforeEvent(name),
getAfterEvent(name)
];
}
var allEvents = _.flatten(_.map(events, function(event) {
if (_.includes(event, 'Result')) {
return [event];
} else {
return getAroundEventsFor(event);
}
}));
events.getBeforeEvent = getBeforeEvent;
events.getAfterEvent = getAfterEvent;
events.ALL = allEvents;
module.exports = events;
},{"lodash":156}],28:[function(require,module,exports){
(function (process){
var path = require('path');
function Listener(options) {
var Cucumber = require('../cucumber');
if (!options) {
options = {};
}
var self = {
hear: function hear(event, defaultTimeout, callback) {
if (self.hasHandlerForEvent(event)) {
var handler = self.getHandlerForEvent(event);
var timeout = self.getTimeout() || defaultTimeout;
Cucumber.Util.run(handler, null, [event.getPayload()], timeout, function(error) {
error = self.prependLocationToError(error);
callback(error);
});
} else {
callback();
}
},
hasHandlerForEvent: function hasHandlerForEvent(event) {
var handlerName = self.buildHandlerNameForEvent(event);
return self[handlerName] !== undefined;
},
buildHandlerNameForEvent: function buildHandlerNameForEvent(event) {
return self.buildHandlerName(event.getName());
},
getHandlerForEvent: function getHandlerForEvent(event) {
var eventHandlerName = self.buildHandlerNameForEvent(event);
return self[eventHandlerName];
},
buildHandlerName: function buildHandler(shortName) {
return Listener.EVENT_HANDLER_NAME_PREFIX + shortName + Listener.EVENT_HANDLER_NAME_SUFFIX;
},
setHandlerForEvent: function setHandlerForEvent(shortname, handler) {
var eventName = self.buildHandlerName(shortname);
self[eventName] = handler;
},
getTimeout: function() {
return options.timeout;
},
getUri: function() {
return options.uri;
},
getLine: function() {
return options.line;
},
prependLocationToError: function(error) {
if (error && self.getUri()) {
var ref = path.relative(process.cwd(), self.getUri()) + ':' + self.getLine() + ' ';
if (error instanceof Error) {
error.message = ref + error.message;
} else {
error = ref + error;
}
}
return error;
},
};
return self;
}
Listener.EVENT_HANDLER_NAME_PREFIX = 'handle';
Listener.EVENT_HANDLER_NAME_SUFFIX = 'Event';
Listener.Formatter = require('./listener/formatter');
Listener.PrettyFormatter = require('./listener/pretty_formatter');
Listener.ProgressFormatter = require('./listener/progress_formatter');
Listener.JsonFormatter = require('./listener/json_formatter');
Listener.RerunFormatter = require('./listener/rerun_formatter');
Listener.SnippetsFormatter = require('./listener/snippets_formatter');
Listener.SummaryFormatter = require('./listener/summary_formatter');
module.exports = Listener;
}).call(this,require('_process'))
},{"../cucumber":1,"./listener/formatter":29,"./listener/json_formatter":30,"./listener/pretty_formatter":31,"./listener/progress_formatter":32,"./listener/rerun_formatter":33,"./listener/snippets_formatter":34,"./listener/summary_formatter":35,"_process":162,"path":160}],29:[function(require,module,exports){
(function (process){
function Formatter(options) {
var Cucumber = require('../../cucumber');
if (!options)
options = {};
var logs = '';
var self = Cucumber.Listener();
self.log = function log(string) {
logs += string;
if (options.stream)
options.stream.write(string);
if (typeof(options.logToFunction) === 'function')
options.logToFunction(string);
};
self.finish = function finish(callback) {
if (options.stream && options.stream !== process.stdout)
options.stream.end(callback);
else
callback();
};
self.getLogs = function getLogs() {
return logs;
};
return self;
}
module.exports = Formatter;
}).call(this,require('_process'))
},{"../../cucumber":1,"_process":162}],30:[function(require,module,exports){
(function (Buffer){
/* jshint -W106 */
function JsonFormatter(options) {
var Cucumber = require('../../cucumber');
var self = Cucumber.Listener.Formatter(options);
var features = [];
var currentFeature;
var currentScenario;
var formatTag = function formatTag(tag) {
return {
name: tag.getName(),
line: tag.getLine()
};
};
self.handleBeforeFeatureEvent = function handleBeforeFeatureEvent(feature) {
currentFeature = {
description: feature.getDescription(),
elements: [],
id: feature.getName().replace(/ /g, '-').toLowerCase(),
keyword: feature.getKeyword(),
line: feature.getLine(),
name: feature.getName(),
tags: feature.getTags().map(formatTag),
uri: feature.getUri()
};
features.push(currentFeature);
};
self.handleBeforeScenarioEvent = function handleBeforeScenarioEvent(scenario) {
currentScenario = {
description: scenario.getDescription(),
id: currentFeature.id + ';' + scenario.getName().replace(/ /g, '-').toLowerCase(),
keyword: 'Scenario',
line: scenario.getLine(),
name: scenario.getName(),
steps: [],
tags: scenario.getTags().map(formatTag),
type: 'scenario'
};
currentFeature.elements.push(currentScenario);
};
self.handleStepResultEvent = function handleStepResultEvent(stepResult) {
var step = stepResult.getStep();
var status = stepResult.getStatus();
var currentStep = {
arguments: step.getArguments().map(function(arg) {
switch (arg.getType()) {
case 'DataTable':
return {
rows: arg.raw().map(function (row) {
return { cells: row };
})
};
case 'DocString':
return {
line: arg.getLine(),
content: arg.getContent(),
contentType: arg.getContentType()
};
default:
throw new Error('Unknown argument type:' + arg.getType());
}
}),
keyword: step.getKeyword(),
name: step.getName(),
result: {
status: status
}
};
if (step.isHidden()) {
currentStep.hidden = true;
} else {
currentStep.line = step.getLine();
}
if (status === Cucumber.Status.PASSED || status === Cucumber.Status.FAILED) {
currentStep.result.duration = stepResult.getDuration();
}
if (stepResult.hasAttachments()) {
currentStep.embeddings = stepResult.getAttachments().map(function (attachment) {
var data = attachment.getData();
if (!(data instanceof Buffer)) {
data = new Buffer(data);
}
return {
data: data.toString('base64'),
mime_type: attachment.getMimeType(),
};
});
}
if (status === Cucumber.Status.FAILED) {
var failureMessage = stepResult.getFailureException();
if (failureMessage) {
currentStep.result.error_message = (failureMessage.stack || failureMessage);
}
}
var stepDefinition = stepResult.getStepDefinition();
if (stepDefinition) {
var location = stepDefinition.getUri() + ':' + stepDefinition.getLine();
currentStep.match = {location: location};
}
currentScenario.steps.push(currentStep);
};
self.handleAfterFeaturesEvent = function handleAfterFeaturesEvent(event, callback) {
self.log(JSON.stringify(features, null, 2));
self.finish(callback);
};
return self;
}
module.exports = JsonFormatter;
}).call(this,require("buffer").Buffer)
},{"../../cucumber":1,"buffer":73}],31:[function(require,module,exports){
function PrettyFormatter(options) {
var Cucumber = require('../../cucumber');
var colors = Cucumber.Util.Colors(options.useColors);
var self = Cucumber.Listener.Formatter(options);
var summaryFormatter = Cucumber.Listener.SummaryFormatter({
snippetSyntax: options.snippetSyntax,
useColors: options.useColors
});
var parentHear = self.hear;
self.hear = function hear(event, defaultTimeout, callback) {
summaryFormatter.hear(event, defaultTimeout, function () {
parentHear(event, defaultTimeout, callback);
});
};
var characters = {};
characters[Cucumber.Status.AMBIGUOUS] = '✖';
characters[Cucumber.Status