api-bdd-test
Version:
use the bdd(cucumber) to test the RESTfull API
368 lines (327 loc) • 11.3 kB
JavaScript
(function() {
var Features, Platform, Promise, Yadda, appRoot, chai, chaiSubset, cleanArray, container, firstline, getLanguageFromFileName, has_annotation, indexOfObject, isArray, isFunction, isString, path, platform, requireAll, resolveDirFromRoot, upperCaseFirstLetter;
Promise = require('bluebird');
Yadda = require('yadda');
chai = require('chai');
chaiSubset = require('chai-subset');
path = require('path');
firstline = require('./first-line');
appRoot = require('app-root-path');
requireAll = require('require-all');
isArray = require('util-ex/lib/is/type/array');
isString = require('util-ex/lib/is/type/string');
isFunction = require('util-ex/lib/is/type/function');
Platform = require('yadda/lib/Platform');
chai.use(chaiSubset);
platform = Platform();
container = platform.get_container();
container.expect = chai.expect;
container.assert = chai.assert;
container.should = chai.should();
container.testScope = {};
cleanArray = function() {
var i;
i = 0;
while (i < this.length) {
if (this[i] == null) {
this.splice(i, 1);
} else {
i++;
}
}
return this;
};
has_annotation = function(annotations, name, language) {
var k, regexp, result, v;
try {
name = language.localise(name);
} catch (undefined) {}
regexp = new RegExp('^' + name + '$', 'i');
result = false;
for (k in annotations) {
v = annotations[k];
result = regexp.test(k) && v;
if (result) {
break;
}
}
return result;
};
resolveDirFromRoot = function(aDir, aRootDir) {
var v;
if (isArray(aDir)) {
aDir = (function() {
var j, len, results;
results = [];
for (j = 0, len = aDir.length; j < len; j++) {
v = aDir[j];
results.push(path.resolve(aRootDir, v));
}
return results;
})();
} else if (isString(aDir)) {
aDir = [path.resolve(aRootDir, aDir)];
}
return aDir;
};
module.exports = Features = (function() {
var yaddaRun;
function Features(aOptions) {
var s;
if (aOptions == null) {
aOptions = {};
}
if (!(this instanceof Features)) {
return new Features(aOptions);
}
this.context = aOptions.context;
this.lang = aOptions.lang || aOptions.language;
this.useDefaultDict = aOptions.defaultDict;
if (this.useDefaultDict == null) {
this.useDefaultDict = true;
}
this.useDefaultLib = aOptions.defaultLib;
if (this.useDefaultLib == null) {
this.useDefaultLib = true;
}
if (s = this.lang) {
this.lang = Yadda.localisation[s];
if (!this.lang) {
console.error('no such default language:', s);
}
}
if (!this.lang) {
this.lang = Yadda.localisation["default"];
}
this.rootDir = aOptions.cwd || './test';
this.featuresDir = aOptions.features || path.join(this.rootDir, 'features');
this.stepsDir = aOptions.steps || path.join(this.rootDir, 'steps');
this.libsDir = aOptions.libs || path.join(this.rootDir, 'libs');
this.rootDir = path.resolve(appRoot.path, this.rootDir);
this.libsDir = resolveDirFromRoot(this.libsDir, appRoot.path);
this.featuresDir = path.resolve(appRoot.path, this.featuresDir);
this.stepsDir = path.resolve(appRoot.path, this.stepsDir);
}
Features.prototype.setLang = function(aLangName) {
var lang;
if (aLangName) {
lang = Yadda.localisation[aLangName];
if (!lang) {
console.error('no such language:', aLangName);
}
}
if (!lang) {
lang = this.lang;
aLangName = indexOfObject(Yadda.localisation, lang);
}
Yadda.plugins.mocha.StepLevelPlugin.init({
language: lang
});
return aLangName;
};
Features.prototype.requireLibs = function(aLibsDir, aLibrary, aDictionary, aLanguage, aFilter) {
var dir, j, len, results;
if (aFilter == null) {
aFilter = /^([^.-].*)[.-](lib[s]?|dict[s]?)\.(js|coffee)$/;
}
if (isString(aLibsDir)) {
aLibsDir = [aLibsDir];
}
if (isArray(aLibsDir)) {
results = [];
for (j = 0, len = aLibsDir.length; j < len; j++) {
dir = aLibsDir[j];
try {
requireAll({
dirname: dir,
filter: aFilter,
recursive: false,
resolve: function(lib) {
return lib.call(aLibrary, aDictionary);
}
});
} catch (undefined) {}
try {
results.push(requireAll({
dirname: path.join(dir, aLanguage.toLowerCase()),
filter: aFilter,
recursive: false,
resolve: function(lib) {
return lib.call(aLibrary, aDictionary);
}
}));
} catch (undefined) {}
}
return results;
}
};
Features.prototype.loadDefaultDict = function(aFeature, aLibrary, aDictionary, aLangName) {
return this.requireLibs(path.join(__dirname, 'default'), aLibrary, aDictionary, aLangName, /^([^\.\-].*)[\-\.]dict[s]?\.(js|coffee)$/);
};
Features.prototype.loadDefaultLib = function(aFeature, aLibrary, aDictionary, aLangName) {
return this.requireLibs(path.join(__dirname, 'default'), aLibrary, aDictionary, aLangName, /^([^\.\-].*)[\-\.]lib[s]?\.(js|coffee)$/);
};
Features.prototype.moveHooksTo = function(aFeature, aLang) {
var aDest, i, j, k, len, scenario, scenarios, v;
aDest = {
before: [],
after: [],
beforeEach: [],
afterEach: [],
beforeStep: [],
afterStep: []
};
scenarios = aFeature.scenarios;
for (i = j = 0, len = scenarios.length; j < len; i = ++j) {
scenario = scenarios[i];
for (k in aDest) {
v = aDest[k];
if (has_annotation(scenario.annotations, k, aLang)) {
v.push(scenario);
scenarios[i] = void 0;
}
}
}
cleanArray.call(scenarios);
return aDest;
};
yaddaRun = null;
Features.prototype.processHook = function(aHooks, yadda, context, lang) {
var j, k, len, scenario, v;
if (!yaddaRun) {
yaddaRun = Promise.promisify(yadda.run);
}
for (k in aHooks) {
v = aHooks[k];
if (v && v.length) {
for (j = 0, len = v.length; j < len; j++) {
scenario = v[j];
if (!has_annotation(scenario.annotations, 'pending', lang)) {
(function(scenario, hookName) {
switch (hookName) {
case 'beforeEach':
hookName = 'before';
break;
case 'afterEach':
hookName = 'after';
break;
case 'beforeStep':
hookName = 'beforeEach';
break;
case 'afterStep':
hookName = 'afterEach';
}
return container[hookName](scenario.title, function() {
return Promise.mapSeries(scenario.steps, function(step) {
testScope.context = context.ctx;
return yaddaRun.call(yadda, step);
});
});
})(scenario, k);
}
}
}
}
};
Features.prototype.runFile = function(aFile, aLangName) {
var aLang;
aLang = Yadda.localisation[aLangName];
return featureFile(aFile, (function(_this) {
return function(feature) {
var context, dictionary, i, j, len, libraries, library, ref, useDefaultDict, useDefaultLib, vBaseName, vGHooks, vHooks, yadda;
context = {
dir: path.dirname(aFile),
file: aFile,
language: aLangName,
ctx: {}
};
if (isFunction(_this.beforeFeature)) {
_this.beforeFeature(feature, context);
}
useDefaultDict = feature.annotations.defaultDict;
if (useDefaultDict == null) {
useDefaultDict = _this.useDefaultDict;
}
useDefaultLib = feature.annotations.defaultLib;
if (useDefaultLib == null) {
useDefaultLib = _this.useDefaultLib;
}
libraries = [];
dictionary = new Yadda.Dictionary();
library = aLang.library(dictionary);
if (useDefaultDict) {
_this.loadDefaultDict(feature, library, dictionary, aLangName);
}
if (useDefaultLib) {
_this.loadDefaultLib(feature, library, dictionary, aLangName);
}
libraries.push(library);
_this.requireLibs(_this.libsDir, library, dictionary, aLangName);
try {
vBaseName = path.basename(aFile).split('.')[0];
_this.requireLibs(_this.stepsDir, library, dictionary, aLangName, new RegExp("^(" + vBaseName + ")(?:\\." + aLangName + ")?[.-]step[s]?\\.(?:js|coffee)$", 'i'));
} catch (undefined) {}
context = Object.assign({}, _this.context, context);
yadda = Yadda.createInstance(libraries, context);
vGHooks = _this.moveHooksTo(feature, aLang);
vHooks = {};
ref = ['before', 'after', 'beforeStep', 'afterStep'];
for (j = 0, len = ref.length; j < len; j++) {
i = ref[j];
vHooks[i] = vGHooks[i];
delete vGHooks[i];
}
_this.processHook(vHooks, yadda, context, aLang);
return scenarios(feature.scenarios, function(scenario) {
_this.processHook(vGHooks, yadda, context, aLang);
return steps(scenario.steps, function(step, done) {
testScope.context = context.ctx;
return yadda.run(step, done);
});
});
};
})(this));
};
Features.prototype.run = function() {
if (isFunction(this.before)) {
this.before();
}
return new Yadda.FeatureFileSearch(this.featuresDir).each((function(_this) {
return function(file) {
var lang;
lang = getLanguageFromFileName(file);
if (!lang) {
lang = /^\s*#\s*language:\s*(\S+)/.exec(firstline(file));
if (lang) {
lang = upperCaseFirstLetter(lang[1]);
}
}
return _this.runFile(file, _this.setLang(lang));
};
})(this));
};
return Features;
})();
upperCaseFirstLetter = function(word) {
return word.charAt(0).toUpperCase() + word.slice(1);
};
getLanguageFromFileName = function(aFileName) {
var result;
aFileName = path.basename(aFileName);
result = path.extname(aFileName.substring(0, aFileName.length - '.feature'.length));
if (result) {
result = upperCaseFirstLetter(result.slice(1));
}
return result;
};
indexOfObject = function(aObj, aValue) {
var k, v;
for (k in aObj) {
v = aObj[k];
if (v === aValue) {
return k;
}
}
};
}).call(this);
//# sourceMappingURL=features.js.map