@touca/node
Version:
Touca SDK for JavaScript
399 lines • 18.3 kB
JavaScript
// Copyright 2023 Touca, Inc. Subject to Apache-2.0 License.
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
import fs from 'node:fs';
import path from 'node:path';
import util from 'node:util';
import chalk from 'chalk';
import { gte } from 'semver';
import { updateRunnerOptions } from './options.js';
var Statistics = /** @class */ (function () {
function Statistics() {
this._values = {};
}
Statistics.prototype.inc = function (name) {
if (!(name in this._values)) {
this._values[name] = 0;
}
this._values[name] += 1;
};
Statistics.prototype.count = function (name) {
var _a;
return (_a = this._values[name]) !== null && _a !== void 0 ? _a : 0;
};
return Statistics;
}());
var Timer = /** @class */ (function () {
function Timer() {
this.v = {};
}
Timer.prototype.tic = function (name) {
this.v[name] = { tic: new Date().getTime() };
};
Timer.prototype.toc = function (name) {
this.v[name].duration = new Date().getTime() - this.v[name].tic;
};
Timer.prototype.count = function (name) {
return this.v[name].duration || 0;
};
return Timer;
}());
var Printer = /** @class */ (function () {
function Printer(colored_output, testcase_width, testcase_count) {
this.colored_output = colored_output;
this.testcase_width = testcase_width;
this.testcase_count = testcase_count;
}
Printer.printError = function (fmt) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
process.stderr.write(util.format.apply(util, __spreadArray([fmt], __read(args), false)));
};
Printer.printAppHeader = function () {
process.stdout.write('\nTouca Test Runner\n');
};
Printer.printAppFooter = function () {
process.stdout.write('\n✨ Ran all test suites.\n\n');
};
Printer.prototype.print = function (fmt) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
process.stdout.write(util.format.apply(util, __spreadArray([fmt], __read(args), false)));
};
Printer.prototype.print_color = function (color, fmt) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
var msg = util.format.apply(util, __spreadArray([fmt], __read(args), false));
process.stdout.write(this.colored_output ? color(msg) : msg);
};
Printer.prototype.print_header = function (suite, version) {
this.print('\nSuite: %s/%s\n\n', suite, version);
};
Printer.prototype.print_progress = function (index, status, testcase, timer, errors) {
if (errors === void 0) { errors = []; }
var badge = {
Sent: { color: chalk.bgGreen, text: ' SENT ' },
Skip: { color: chalk.bgYellow, text: ' SKIP ' },
Fail: { color: chalk.bgRed, text: ' FAIL ' },
Pass: { color: chalk.bgGreen, text: ' PASS ' },
Diff: { color: chalk.bgYellow, text: ' DIFF ' }
}[status];
var pad = Math.floor(Math.log10(this.testcase_count)) + 1;
this.print(' %s', String(index + 1).padStart(pad));
this.print_color(chalk.blackBright, '. ');
this.print_color(badge.color, badge.text);
this.print(' %s', testcase.padEnd(this.testcase_width));
if (status !== 'Skip') {
this.print_color(chalk.blackBright, ' (%d ms)', timer.count(testcase));
}
this.print('\n');
if (errors.length) {
var list = errors.map(function (v) { return util.format(' - %s', v); }).join('\n');
this.print_color(chalk.blackBright, '\n Exception Raised:');
this.print('\n%s\n\n', list);
}
};
Printer.prototype.printFooter = function (stats, timer, options) {
var _a;
var duration = (timer.count('__workflow__') / 1000.0).toFixed(2);
var report = function (status, text, color) {
if (!stats.count(status)) {
return '';
}
var msg = util.format('%d %s', stats.count(status), text);
return options.colored_output ? color(msg) : msg;
};
var pad = Math.floor(Math.log10(options.testcases.length)) + 11;
var counts = [
report('Sent', 'submitted', chalk.green),
report('Skip', 'skipped', chalk.yellow),
report('Fail', 'failed', chalk.red),
report('Pass', 'perfect', chalk.green),
report('Diff', 'different', chalk.yellow),
util.format('%d total', options.testcases.length)
].filter(function (v) { return v.length; });
this.print('\n%s %s\n', 'Tests:'.padEnd(pad), counts.join(', '));
this.print('%s %f s\n', 'Time:'.padEnd(pad), duration);
if ((_a = options.webUrl) === null || _a === void 0 ? void 0 : _a.length) {
this.print('%s %s/~/%s/%s/%s\n', 'Link:'.padEnd(pad), options.webUrl, options.team, options.suite, options.version);
}
if (options.save_binary || options.save_json) {
this.print('%s %s\n', 'Results:'.padEnd(pad), path.join(options.output_directory, options.suite, options.version));
}
};
return Printer;
}());
function getWorkflowOptions(options) {
if (!options.workflows) {
return [];
}
return options.workflows.map(function (w) {
var config_file = options.config_file, workflows = options.workflows, workflow_filter = options.workflow_filter, rest = __rest(options, ["config_file", "workflows", "workflow_filter"]);
return __assign(__assign({}, rest), w);
});
}
function runWorkflow(client, options) {
return __awaiter(this, void 0, void 0, function () {
var printer, timer, stats, _a, _b, _c, index, testcase, testcase_directory, skip, func, errors, err_1, error, status_1, filepath, filepath, e_1_1;
var e_1, _d;
return __generator(this, function (_e) {
switch (_e.label) {
case 0: return [4 /*yield*/, client.configure(options)];
case 1:
_e.sent();
printer = new Printer(options.colored_output, options.testcases.reduce(function (sum, tc) { return Math.max(tc.length, sum); }, 0), options.testcases.length);
printer.print_header(options.suite, options.version);
timer = new Timer();
stats = new Statistics();
timer.tic('__workflow__');
_e.label = 2;
case 2:
_e.trys.push([2, 16, 17, 18]);
_a = __values(options.testcases.entries()), _b = _a.next();
_e.label = 3;
case 3:
if (!!_b.done) return [3 /*break*/, 15];
_c = __read(_b.value, 2), index = _c[0], testcase = _c[1];
testcase_directory = path.join(options.output_directory, options.suite, options.version, testcase);
skip = options.save_binary
? fs.existsSync(path.join(testcase_directory, 'touca.bin'))
: options.save_json
? fs.existsSync(path.join(testcase_directory, 'touca.json'))
: false;
if (!options.overwrite_results && skip) {
printer.print_progress(index, 'Skip', testcase, timer);
stats.inc('Skip');
return [3 /*break*/, 14];
}
if (fs.existsSync(testcase_directory)) {
func = gte(process.version, '15.0.0') ? fs.rmSync : fs.rmdirSync;
func(testcase_directory, { recursive: true });
fs.mkdirSync(testcase_directory);
}
client.declare_testcase(testcase);
timer.tic(testcase);
errors = [];
_e.label = 4;
case 4:
_e.trys.push([4, 6, , 7]);
return [4 /*yield*/, options.callback(testcase)];
case 5:
_e.sent();
return [3 /*break*/, 7];
case 6:
err_1 = _e.sent();
error = err_1 instanceof Error ? err_1.message : 'Unknown Error';
errors.push(error);
return [3 /*break*/, 7];
case 7:
timer.toc(testcase);
status_1 = errors.length ? 'Fail' : 'Sent';
if (!(errors.length === 0 && options.save_binary)) return [3 /*break*/, 9];
filepath = path.join(testcase_directory, 'touca.bin');
return [4 /*yield*/, client.save_binary(filepath, [testcase])];
case 8:
_e.sent();
_e.label = 9;
case 9:
if (!(errors.length === 0 && options.save_json)) return [3 /*break*/, 11];
filepath = path.join(testcase_directory, 'touca.json');
return [4 /*yield*/, client.save_json(filepath, [testcase])];
case 10:
_e.sent();
_e.label = 11;
case 11:
if (!(errors.length === 0 && !options.offline)) return [3 /*break*/, 13];
return [4 /*yield*/, client.post({
submit_async: options.submit_async
})];
case 12:
status_1 = _e.sent();
_e.label = 13;
case 13:
stats.inc(status_1);
printer.print_progress(index, status_1, testcase, timer, errors);
client.forget_testcase(testcase);
_e.label = 14;
case 14:
_b = _a.next();
return [3 /*break*/, 3];
case 15: return [3 /*break*/, 18];
case 16:
e_1_1 = _e.sent();
e_1 = { error: e_1_1 };
return [3 /*break*/, 18];
case 17:
try {
if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
}
finally { if (e_1) throw e_1.error; }
return [7 /*endfinally*/];
case 18:
timer.toc('__workflow__');
printer.printFooter(stats, timer, options);
if (!!options.offline) return [3 /*break*/, 20];
return [4 /*yield*/, client.seal()];
case 19:
_e.sent();
_e.label = 20;
case 20: return [2 /*return*/];
}
});
});
}
export function run(options, transport, client) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b, workflowOptions, error_1, prefix, message, e_2_1;
var e_2, _c;
return __generator(this, function (_d) {
switch (_d.label) {
case 0: return [4 /*yield*/, updateRunnerOptions(options, transport)];
case 1:
_d.sent();
if ((options.save_binary || options.save_json) &&
options.output_directory &&
!fs.existsSync(options.output_directory)) {
fs.mkdirSync(options.output_directory, { recursive: true });
}
Printer.printAppHeader();
_d.label = 2;
case 2:
_d.trys.push([2, 9, 10, 11]);
_a = __values(getWorkflowOptions(options)), _b = _a.next();
_d.label = 3;
case 3:
if (!!_b.done) return [3 /*break*/, 8];
workflowOptions = _b.value;
_d.label = 4;
case 4:
_d.trys.push([4, 6, , 7]);
return [4 /*yield*/, runWorkflow(client, workflowOptions)];
case 5:
_d.sent();
return [3 /*break*/, 7];
case 6:
error_1 = _d.sent();
prefix = "Error when running suite \"".concat(workflowOptions.suite, "\"");
message = error_1.message;
Printer.printError('\n%s:\n%s\n', prefix, message);
return [3 /*break*/, 7];
case 7:
_b = _a.next();
return [3 /*break*/, 3];
case 8: return [3 /*break*/, 11];
case 9:
e_2_1 = _d.sent();
e_2 = { error: e_2_1 };
return [3 /*break*/, 11];
case 10:
try {
if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
}
finally { if (e_2) throw e_2.error; }
return [7 /*endfinally*/];
case 11:
Printer.printAppFooter();
return [2 /*return*/];
}
});
});
}
//# sourceMappingURL=runner.js.map