427 lines
18 KiB
JavaScript
427 lines
18 KiB
JavaScript
|
"use strict";
|
||
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
|
|
if (k2 === undefined) k2 = k;
|
||
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
||
|
|
}
|
||
|
|
Object.defineProperty(o, k2, desc);
|
||
|
|
}) : (function(o, m, k, k2) {
|
||
|
|
if (k2 === undefined) k2 = k;
|
||
|
|
o[k2] = m[k];
|
||
|
|
}));
|
||
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
|
|
}) : function(o, v) {
|
||
|
|
o["default"] = v;
|
||
|
|
});
|
||
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
||
|
|
if (mod && mod.__esModule) return mod;
|
||
|
|
var result = {};
|
||
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
|
|
__setModuleDefault(result, mod);
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||
|
|
};
|
||
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||
|
|
const path_1 = __importDefault(require("path"));
|
||
|
|
const fs_1 = __importDefault(require("fs"));
|
||
|
|
const util_1 = __importDefault(require("util"));
|
||
|
|
const async_1 = __importDefault(require("async"));
|
||
|
|
const strip_bom_1 = __importDefault(require("strip-bom"));
|
||
|
|
const pinkie_1 = __importDefault(require("pinkie"));
|
||
|
|
const uglify_js_1 = require("../tools/uglify-js/uglify-js");
|
||
|
|
const uglify_js_2 = require("../tools/uglify-js/uglify-js");
|
||
|
|
const Common = __importStar(require("./common"));
|
||
|
|
const Ast = __importStar(require("./ast"));
|
||
|
|
const CallAnalyzer = __importStar(require("./analysis/call_analyzer"));
|
||
|
|
const steps_analyzer_1 = __importDefault(require("./analysis/steps_analyzer"));
|
||
|
|
const ErrCodes = __importStar(require("./err_codes"));
|
||
|
|
const promisify_1 = __importDefault(require("../../utils/promisify"));
|
||
|
|
var readFile = (0, promisify_1.default)(fs_1.default.readFile);
|
||
|
|
//Util
|
||
|
|
//NOTE: this is a version of splice which can operate with array of the injectable items
|
||
|
|
function multySplice(arr, index, deleteCount, itemsToInsert) {
|
||
|
|
var args = [index, deleteCount].concat(itemsToInsert);
|
||
|
|
arr.splice.apply(arr, args);
|
||
|
|
}
|
||
|
|
//Compiler
|
||
|
|
function Compiler(src, filename, modules, requireReader, sourceIndex, hammerheadProcessScript) {
|
||
|
|
this.walker = uglify_js_1.uglify.ast_walker();
|
||
|
|
this.hammerheadProcessScript = hammerheadProcessScript;
|
||
|
|
this.filename = filename;
|
||
|
|
this.src = src;
|
||
|
|
this.workingDir = path_1.default.dirname(this.filename);
|
||
|
|
this.modules = modules;
|
||
|
|
this.requireReader = requireReader;
|
||
|
|
this.sourceIndex = sourceIndex || [];
|
||
|
|
this.requires = [];
|
||
|
|
this.line = 0;
|
||
|
|
this.errs = [];
|
||
|
|
this.okFlag = true;
|
||
|
|
this.rawTestsStepData = {};
|
||
|
|
this.rawMixinsStepData = {};
|
||
|
|
this.out = {
|
||
|
|
fixture: '',
|
||
|
|
page: '',
|
||
|
|
authCredentials: null,
|
||
|
|
requireJs: '',
|
||
|
|
remainderJs: '',
|
||
|
|
testsStepData: {},
|
||
|
|
workingDir: this.workingDir,
|
||
|
|
testGroupMap: {}
|
||
|
|
};
|
||
|
|
this.testAnalyzer = new steps_analyzer_1.default(false, this.rawTestsStepData, this.errs, this.sourceIndex);
|
||
|
|
this.mixinAnalyzer = new steps_analyzer_1.default(true, this.rawMixinsStepData, this.errs, this.sourceIndex);
|
||
|
|
}
|
||
|
|
exports.default = Compiler;
|
||
|
|
;
|
||
|
|
Object.defineProperties(Compiler.prototype, {
|
||
|
|
ok: {
|
||
|
|
get: function () {
|
||
|
|
return !this.errs.length && this.okFlag;
|
||
|
|
},
|
||
|
|
set: function (value) {
|
||
|
|
this.okFlag = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Compiler.prototype._err = function (type, filename, line, additionalFields) {
|
||
|
|
this.errs.push(Common.createErrorObj(type, filename, line, additionalFields));
|
||
|
|
};
|
||
|
|
Compiler.prototype._fixtureErr = function (type, line, additionalFields) {
|
||
|
|
this._err(type, this.filename, line, additionalFields);
|
||
|
|
};
|
||
|
|
Compiler.prototype._addRequire = function (require) {
|
||
|
|
if (this.requires.indexOf(require) > -1)
|
||
|
|
this._fixtureErr(ErrCodes.REQUIRED_FILE_ALREADY_INCLUDED, this.line, { req: require });
|
||
|
|
else
|
||
|
|
this.requires.push(require);
|
||
|
|
};
|
||
|
|
Compiler.prototype._compileDirective = function (match) {
|
||
|
|
switch (match[1]) {
|
||
|
|
case Common.AUTH_DIRECTIVE_LVALUE:
|
||
|
|
if (this.out.authCredentials) {
|
||
|
|
this._fixtureErr(ErrCodes.AUTH_DIRECTIVE_REDEFINITION, this.line);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var credentials = Common.AUTH_CREDENTIALS_REGEXP.exec(match[2]);
|
||
|
|
if (!credentials || credentials.length < 3) {
|
||
|
|
this._fixtureErr(ErrCodes.INVALID_NETWORK_AUTHENTICATION_CREDENTIALS_FORMAT, this.line);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
this.out.authCredentials = {
|
||
|
|
username: credentials[1],
|
||
|
|
password: credentials[2]
|
||
|
|
};
|
||
|
|
break;
|
||
|
|
case Common.FIXTURE_DIRECTIVE_LVALUE:
|
||
|
|
if (this.out.fixture) {
|
||
|
|
this._fixtureErr(ErrCodes.FIXTURE_DIRECTIVE_REDEFINITION, this.line);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
this.out.fixture = match[2];
|
||
|
|
break;
|
||
|
|
case Common.PAGE_DIRECTIVE_LVALUE:
|
||
|
|
if (this.out.page) {
|
||
|
|
this._fixtureErr(ErrCodes.PAGE_DIRECTIVE_REDEFINITION, this.line);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
this.out.page = match[2];
|
||
|
|
break;
|
||
|
|
case Common.REQUIRE_DIRECTIVE_LVALUE:
|
||
|
|
if (match[2].indexOf(Common.MODULE_PREFIX) === 0) {
|
||
|
|
var moduleName = match[2].slice(1), moduleFiles = this.modules && this.modules[moduleName];
|
||
|
|
if (!moduleFiles) {
|
||
|
|
this._fixtureErr(ErrCodes.MODULE_NOT_FOUND, this.line, { moduleName: moduleName });
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var compiler = this;
|
||
|
|
moduleFiles.forEach(function (moduleFile) {
|
||
|
|
compiler._addRequire(moduleFile);
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
var require = path_1.default.join(this.workingDir, match[2]);
|
||
|
|
this._addRequire(require);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
//NOTE: valid directive expression must match following AST path:
|
||
|
|
//'toplevel' -> 'stat' -> [string, DIRECTIVE_EXPRESSION].
|
||
|
|
//Also it's important to perform this test here, when we sure that this is a directive expression
|
||
|
|
//and not just a string that starts with @
|
||
|
|
if (!Ast.isPathMatch(Common.DIRECTIVE_EXPRESSION_AST_PATH, this.walker.stack()))
|
||
|
|
this._fixtureErr(ErrCodes.MISPLACED_DIRECTIVE, this.line);
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
Compiler.prototype._getRemainderCode = function (ast) {
|
||
|
|
var remainderAst = Ast.getRemainderAst(ast);
|
||
|
|
if (remainderAst) {
|
||
|
|
CallAnalyzer.run(remainderAst, this.filename, this.errs, true, this.sourceIndex, this.src);
|
||
|
|
if (this.ok) {
|
||
|
|
var remainderCode = uglify_js_1.uglify.gen_code(remainderAst, { beautify: true });
|
||
|
|
return this.hammerheadProcessScript(remainderCode, false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
};
|
||
|
|
Compiler.prototype._analyzeAst = function (ast) {
|
||
|
|
var compiler = this;
|
||
|
|
this.walker.with_walkers({
|
||
|
|
'string': function () {
|
||
|
|
var astPath = compiler.walker.stack(), topStatement = astPath[1][0];
|
||
|
|
compiler.line = Ast.getCurrentSrcLineNum(astPath);
|
||
|
|
var isMixinDeclaration = this[1] === Common.MIXIN_DECLARATION_MARKER, isTestDeclaration = this[1] === Common.TEST_DECLARATION_MARKER;
|
||
|
|
if (isMixinDeclaration || isTestDeclaration) {
|
||
|
|
topStatement.remove = true;
|
||
|
|
var analyzer = isMixinDeclaration ? compiler.mixinAnalyzer : compiler.testAnalyzer;
|
||
|
|
analyzer.run(compiler.walker.stack(), compiler.filename, compiler.src);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// NOTE: Try to find directive expression.
|
||
|
|
// It's a string statement that match DIRECTIVE_EXPRESSION_PATTERN
|
||
|
|
var match = Common.DIRECTIVE_EXPRESSION_PATTERN.exec(this[1]);
|
||
|
|
if (match) {
|
||
|
|
//NOTE: do not unset 'remove' flag if it was already set by test facility parsing algorithm
|
||
|
|
var success = compiler._compileDirective(match);
|
||
|
|
topStatement.remove = topStatement.remove || success;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, function () {
|
||
|
|
compiler.walker.walk(ast);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
//Requires
|
||
|
|
Compiler.prototype._mergeRequireMixins = function (requireDescriptor) {
|
||
|
|
var compiler = this;
|
||
|
|
Object.keys(requireDescriptor.rawMixinsStepData).forEach(function (name) {
|
||
|
|
if (compiler.rawMixinsStepData[name]) {
|
||
|
|
compiler._fixtureErr(ErrCodes.DUPLICATE_MIXIN_NAME_IN_REQUIRE, null, {
|
||
|
|
name: name,
|
||
|
|
defFilename1: requireDescriptor.filename,
|
||
|
|
defFilename2: compiler.rawMixinsStepData[name].reqFilename || compiler.filename
|
||
|
|
});
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
compiler.rawMixinsStepData[name] = requireDescriptor.rawMixinsStepData[name];
|
||
|
|
compiler.rawMixinsStepData[name].reqFilename = requireDescriptor.filename;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
Compiler.prototype._analyzeRequires = function (callback) {
|
||
|
|
var requireReaderPromises = this.requires.map(require => {
|
||
|
|
return this.requireReader
|
||
|
|
.read(require, this.filename, this.sourceIndex)
|
||
|
|
.then(res => {
|
||
|
|
var descriptor = res.descriptor;
|
||
|
|
if (res.fromCache)
|
||
|
|
this.ok = this.ok && !descriptor.hasErrs;
|
||
|
|
else
|
||
|
|
this.errs = this.errs.concat(res.errs);
|
||
|
|
return descriptor;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
pinkie_1.default.all(requireReaderPromises)
|
||
|
|
.then(descriptors => {
|
||
|
|
descriptors.forEach(descriptor => {
|
||
|
|
this._mergeRequireMixins(descriptor);
|
||
|
|
if (this.ok)
|
||
|
|
this.out.requireJs += descriptor.jsCode;
|
||
|
|
});
|
||
|
|
callback();
|
||
|
|
});
|
||
|
|
};
|
||
|
|
//Test steps data compilation
|
||
|
|
Compiler.prototype._insertMixins = function (testStepData) {
|
||
|
|
var stepCount = testStepData.names.length;
|
||
|
|
for (var i = 0; i < stepCount; i++) {
|
||
|
|
var ast = testStepData.asts[i];
|
||
|
|
if (ast.isMixinInsertionPoint) {
|
||
|
|
var mixinStepData = this.rawMixinsStepData[ast.mixinName];
|
||
|
|
if (!mixinStepData) {
|
||
|
|
this._fixtureErr(ErrCodes.UNDEFINED_MIXIN_USED, ast.line, { mixinName: ast.mixinName });
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
var mixinStepNames = [], stepName = testStepData.names[i];
|
||
|
|
for (var j = 0; j < mixinStepData.names.length; j++)
|
||
|
|
mixinStepNames.push(stepName + Common.TEST_MIXIN_STEP_NAME_SEPARATOR + mixinStepData.names[j]);
|
||
|
|
multySplice(testStepData.names, i, 1, mixinStepNames);
|
||
|
|
multySplice(testStepData.asts, i, 1, mixinStepData.asts);
|
||
|
|
i += mixinStepNames.length - 1;
|
||
|
|
stepCount = testStepData.names.length;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Compiler.prototype._populateTestCases = function (testName, testStepData) {
|
||
|
|
var compiler = this, cases = testStepData.testCasesDirectiveAst[1];
|
||
|
|
cases.forEach(function (testCase, index) {
|
||
|
|
var fields = testCase[1], caseName = null, initStats = [];
|
||
|
|
fields.forEach(function (field) {
|
||
|
|
var fieldName = field[0];
|
||
|
|
if (fieldName === Common.TEST_CASE_NAME_FIELD)
|
||
|
|
caseName = field[1][1];
|
||
|
|
else
|
||
|
|
initStats.push(['stat', ['assign', true, ['sub', ['name', 'this'], ['string', fieldName]], field[1]]]);
|
||
|
|
});
|
||
|
|
var initStepAst = ['function', null, [], initStats], genStepData = {
|
||
|
|
names: [Common.TEST_CASE_INIT_STEP_NAME].concat(testStepData.names),
|
||
|
|
asts: [initStepAst].concat(testStepData.asts)
|
||
|
|
}, genTestName = testName +
|
||
|
|
Common.TEST_CASE_NAME_SEPARATOR +
|
||
|
|
(caseName || util_1.default.format(Common.TEST_CASE_DEFAULT_NAME_PATTERN, index));
|
||
|
|
compiler.out.testGroupMap[genTestName] = testName;
|
||
|
|
compiler._addOutputTestStepData(genTestName, genStepData);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
Compiler.prototype._addOutputTestStepData = function (testName, testStepData) {
|
||
|
|
var js = uglify_js_1.uglify.gen_code(['array', testStepData.asts], { beautify: true });
|
||
|
|
this.out.testsStepData[testName] = {
|
||
|
|
names: testStepData.names,
|
||
|
|
js: this.hammerheadProcessScript(js, false)
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Compiler.prototype._compileTestsStepData = function () {
|
||
|
|
var compiler = this, testNames = Object.keys(this.rawTestsStepData);
|
||
|
|
testNames.forEach(function (testName) {
|
||
|
|
var testStepData = compiler.rawTestsStepData[testName];
|
||
|
|
compiler._insertMixins(testStepData);
|
||
|
|
if (compiler.ok) {
|
||
|
|
if (testStepData.testCasesDirectiveAst)
|
||
|
|
compiler._populateTestCases(testName, testStepData);
|
||
|
|
else
|
||
|
|
compiler._addOutputTestStepData(testName, testStepData);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
//Test cases preparation
|
||
|
|
Compiler.prototype._parseExternalTestCases = function (data) {
|
||
|
|
var ast = null;
|
||
|
|
try {
|
||
|
|
ast = uglify_js_2.parser.parse(data.toString().trim(), false, true);
|
||
|
|
}
|
||
|
|
catch (parserErr) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
//NOTE: extract testCases array from first statement [toplevel]->[stat]->[array]
|
||
|
|
return ast && ast[1] && ast[1][0] && ast[1][0][1];
|
||
|
|
};
|
||
|
|
Compiler.prototype._validateTestCase = function (caseAst, filename, namesMap) {
|
||
|
|
if (caseAst[0].name !== 'object') {
|
||
|
|
this._err(ErrCodes.TEST_CASE_IS_NOT_AN_OBJECT, filename, Ast.getCurrentSrcLineNum(caseAst));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var fields = caseAst[1];
|
||
|
|
if (!fields.length) {
|
||
|
|
this._err(ErrCodes.TEST_CASE_DOESNT_CONTAIN_ANY_FIELDS, filename, Ast.getCurrentSrcLineNum(caseAst));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var nameField = fields.filter(function (field) {
|
||
|
|
return field[0] === Common.TEST_CASE_NAME_FIELD;
|
||
|
|
})[0];
|
||
|
|
if (nameField) {
|
||
|
|
var nameFieldValue = nameField[1];
|
||
|
|
if (nameFieldValue[0].name !== 'string') {
|
||
|
|
this._err(ErrCodes.TEST_CASE_NAME_IS_NOT_A_STRING, filename, Ast.getCurrentSrcLineNum(nameField));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var testCaseName = nameFieldValue[1];
|
||
|
|
if (namesMap[testCaseName])
|
||
|
|
this._err(ErrCodes.DUPLICATE_TEST_CASE_NAME, filename, Ast.getCurrentSrcLineNum(nameField), { testCaseName: testCaseName });
|
||
|
|
else
|
||
|
|
namesMap[testCaseName] = true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
Compiler.prototype._validateTestCaseListAst = function (ast, filename) {
|
||
|
|
if (!ast || !ast[0] || ast[0].name !== 'array') {
|
||
|
|
this._err(ErrCodes.TEST_CASES_LIST_IS_NOT_ARRAY, filename, ast ? Ast.getCurrentSrcLineNum(ast) : 1);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var cases = ast[1];
|
||
|
|
if (!cases.length) {
|
||
|
|
this._err(ErrCodes.TEST_CASES_LIST_IS_EMPTY, filename, Ast.getCurrentSrcLineNum(ast));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var compiler = this, namesMap = [];
|
||
|
|
cases.forEach(function (caseAst) {
|
||
|
|
compiler._validateTestCase(caseAst, filename, namesMap);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
Compiler.prototype._createExternalTestCasesAnalyzer = function (testCasesPath, refTestsStepData) {
|
||
|
|
var compiler = this;
|
||
|
|
return function (readerCallback) {
|
||
|
|
readFile(testCasesPath)
|
||
|
|
.then(data => {
|
||
|
|
data = (0, strip_bom_1.default)(data);
|
||
|
|
var ast = compiler._parseExternalTestCases(data);
|
||
|
|
compiler._validateTestCaseListAst(ast, testCasesPath);
|
||
|
|
refTestsStepData.forEach(function (testStepData) {
|
||
|
|
testStepData.testCasesDirectiveAst = ast;
|
||
|
|
});
|
||
|
|
readerCallback();
|
||
|
|
})
|
||
|
|
.catch(() => {
|
||
|
|
compiler._fixtureErr(ErrCodes.FAILED_TO_READ_EXTERNAL_TEST_CASES, 0, { testCasesPath: testCasesPath });
|
||
|
|
readerCallback();
|
||
|
|
});
|
||
|
|
};
|
||
|
|
};
|
||
|
|
Compiler.prototype._prepareTestCases = function (callback) {
|
||
|
|
var compiler = this, externalTestCases = {}, externalTestCasesAnalyzers = [];
|
||
|
|
Object.keys(this.rawTestsStepData).forEach(function (testName) {
|
||
|
|
var testStepData = compiler.rawTestsStepData[testName];
|
||
|
|
if (testStepData.testCasesDirectiveAst) {
|
||
|
|
//NOTE: we have a test cases from external file. Add it to the external test cases list, then read them,
|
||
|
|
//validate and attach to the appropriate testStepData's
|
||
|
|
if (testStepData.testCasesDirectiveAst[0].name === 'string') {
|
||
|
|
var testCasesPath = path_1.default.join(compiler.workingDir, testStepData.testCasesDirectiveAst[1]);
|
||
|
|
//NOTE: assign absolute path as a directive value
|
||
|
|
testStepData.testCasesDirectiveAst = testCasesPath;
|
||
|
|
//NOTE: create array which will contain all testStepData's which uses this external test case.
|
||
|
|
if (!externalTestCases[testCasesPath])
|
||
|
|
externalTestCases[testCasesPath] = [];
|
||
|
|
externalTestCases[testCasesPath].push(testStepData);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
compiler._validateTestCaseListAst(testStepData.testCasesDirectiveAst, compiler.filename);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
//NOTE: run external test cases analyzers
|
||
|
|
Object.keys(externalTestCases).forEach(function (testCasesPath) {
|
||
|
|
externalTestCasesAnalyzers.push(compiler._createExternalTestCasesAnalyzer(testCasesPath, externalTestCases[testCasesPath]));
|
||
|
|
});
|
||
|
|
async_1.default.parallel(externalTestCasesAnalyzers, callback);
|
||
|
|
};
|
||
|
|
//Compile
|
||
|
|
Compiler.prototype.compile = function (callback) {
|
||
|
|
var compiler = this;
|
||
|
|
var constructed = null;
|
||
|
|
try {
|
||
|
|
constructed = Ast.constructFromCode(this.src, this.filename);
|
||
|
|
}
|
||
|
|
catch (parserErr) {
|
||
|
|
callback([parserErr]);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
var ast = constructed.ast;
|
||
|
|
compiler.src = constructed.preprocessedCode;
|
||
|
|
compiler._analyzeAst(ast);
|
||
|
|
if (!compiler.out.fixture)
|
||
|
|
compiler._fixtureErr(ErrCodes.FIXTURE_DIRECTIVE_IS_UNDEFINED);
|
||
|
|
if (!compiler.out.page)
|
||
|
|
compiler._fixtureErr(ErrCodes.PAGE_DIRECTIVE_IS_UNDEFINED);
|
||
|
|
compiler.out.remainderJs = compiler._getRemainderCode(ast);
|
||
|
|
compiler._analyzeRequires(function () {
|
||
|
|
compiler._prepareTestCases(function () {
|
||
|
|
compiler._compileTestsStepData();
|
||
|
|
if (compiler.ok)
|
||
|
|
callback(null, compiler.out);
|
||
|
|
else
|
||
|
|
callback(compiler.errs);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
};
|