@touca/node
Version:
Touca SDK for JavaScript
307 lines • 12.2 kB
JavaScript
// Copyright 2023 Touca, Inc. Subject to Apache-2.0 License.
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.");
};
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;
};
import { Builder } from 'flatbuffers';
import { ToucaError } from './options.js';
import * as schema from './schema.js';
import { BlobType, IntegerType, VectorType } from './types.js';
var ResultCategory;
(function (ResultCategory) {
ResultCategory[ResultCategory["Check"] = 1] = "Check";
ResultCategory[ResultCategory["Assert"] = 2] = "Assert";
})(ResultCategory || (ResultCategory = {}));
var Case = /** @class */ (function () {
function Case(meta) {
this.meta = meta;
this._results = new Map();
this._tics = new Map();
this._tocs = new Map();
}
/**
* Captures the value of a given variable as a data point for the declared
* test case and associates it with the specified key.
*
* @param key name to be associated with the captured data point
* @param value value to be captured as a test result
* @param options comparison rule for this test result
*/
Case.prototype.check = function (key, value, options) {
var rule = options === null || options === void 0 ? void 0 : options.rule;
this._results.set(key, { typ: ResultCategory.Check, val: value, rule: rule });
};
/**
* Captures an external file as a data point for the declared
* test case and associates it with the specified key.
*
* @param key name to be associated with the captured file
* @param path path to the external file to be captured
*/
Case.prototype.checkFile = function (key, path) {
this._results.set(key, {
typ: ResultCategory.Check,
val: BlobType.fromFile(path)
});
};
/**
* Logs a given value as an assertion for the declared test case
* and associates it with the specified key.
*
* @param key name to be associated with the logged test result
* @param value value to be logged as a test result
*/
Case.prototype.assume = function (key, value) {
this._results.set(key, { typ: ResultCategory.Assert, val: value });
};
/**
* Adds a given value to a list of results for the declared test case which is
* associated with the specified key.
*
* @param key name to be associated with the logged test result
* @param value element to be appended to the array
*/
Case.prototype.add_array_element = function (key, value) {
if (!this._results.has(key)) {
this._results.set(key, {
typ: ResultCategory.Check,
val: new VectorType()
});
}
var val = this._results.get(key);
if (val.typ !== ResultCategory.Check || !(val.val instanceof VectorType)) {
throw new ToucaError('capture_type_mismatch', key);
}
val.val.add(value);
};
/**
* Increments value of key every time it is executed. creates the key with
* initial value of one if it does not exist.
*
* @param key name to be associated with the logged test result
*/
Case.prototype.add_hit_count = function (key) {
if (!this._results.has(key)) {
this._results.set(key, {
typ: ResultCategory.Check,
val: new IntegerType(1)
});
return;
}
var val = this._results.get(key);
if (val.typ !== ResultCategory.Check || !(val.val instanceof IntegerType)) {
throw new ToucaError('capture_type_mismatch', key);
}
val.val.increment();
};
/**
* Adds an already obtained measurements to the list of captured performance
* benchmarks.
*
* Useful for logging a metric that is measured without using this SDK.
*
* @param key name to be associated with this performance benchmark
* @param milliseconds duration of this measurement in milliseconds
*/
Case.prototype.add_metric = function (key, milliseconds) {
var now = new Date();
this._tics.set(key, now.getTime());
now.setMilliseconds(now.getMilliseconds() + milliseconds);
this._tocs.set(key, now.getTime());
};
/**
* Starts timing an event with the specified name.
*
* Measurement of the event is only complete when function `stop_timer` is
* later called for the specified name.
*
* @param key name to be associated with the performance metric
*/
Case.prototype.start_timer = function (key) {
this._tics.set(key, new Date().getTime());
};
/**
* Stops timing an event with the specified name.
*
* Expects function `startTimer` to have been called previously with the
* specified name.
*
* @param key name to be associated with the performance metric
*/
Case.prototype.stop_timer = function (key) {
if (this._tics.has(key)) {
this._tocs.set(key, new Date().getTime());
}
};
Case.prototype._metrics = function () {
var e_1, _a;
var metrics = [];
try {
for (var _b = __values(this._tics), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), key = _d[0], tic = _d[1];
if (!this._tocs.has(key)) {
continue;
}
var toc = this._tocs.get(key);
var diff = new IntegerType(toc - tic);
metrics.push([key, diff]);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return metrics;
};
Case.prototype._metadata = function () {
var _a, _b, _c;
return {
teamslug: (_a = this.meta.team) !== null && _a !== void 0 ? _a : 'unknown',
testsuite: (_b = this.meta.suite) !== null && _b !== void 0 ? _b : 'unknown',
version: (_c = this.meta.version) !== null && _c !== void 0 ? _c : 'unknown',
testcase: this.meta.name,
builtAt: new Date().toUTCString()
};
};
Case.prototype.blobs = function () {
return Array.from(this._results.entries())
.filter(function (v) { return v[1].val instanceof BlobType; })
.map(function (v) { return [v[0], v[1].val]; });
};
Case.prototype.json = function () {
var e_2, _a;
var results = [];
var assertions = [];
try {
for (var _b = __values(this._results.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), key = _d[0], entry = _d[1];
var item = { key: key, value: entry.val.json(), rule: entry.rule };
switch (entry.typ) {
case ResultCategory.Assert:
assertions.push(item);
break;
default:
results.push(item);
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
var metrics = this._metrics().map(function (kvp) { return ({
key: kvp[0],
value: kvp[1].json()
}); });
return {
metadata: this._metadata(),
results: results,
assertions: assertions,
metrics: metrics
};
};
Case.prototype.serialize = function () {
var e_3, _a, e_4, _b;
var result_types = new Map([
[ResultCategory.Check, schema.ResultType.Check],
[ResultCategory.Assert, schema.ResultType.Assert]
]);
var builder = new Builder(1024);
var meta = this._metadata();
var keys = Object.keys(meta);
var metadata = new Map(keys.map(function (k) { return [k, builder.createString(meta[k])]; }));
schema.Metadata.startMetadata(builder);
schema.Metadata.addTeamslug(builder, metadata.get('teamslug'));
schema.Metadata.addTestsuite(builder, metadata.get('testsuite'));
schema.Metadata.addVersion(builder, metadata.get('version'));
schema.Metadata.addTestcase(builder, metadata.get('testcase'));
schema.Metadata.addBuiltAt(builder, metadata.get('builtAt'));
var fbs_metadata = schema.Metadata.endMetadata(builder);
var result_entries = [];
try {
for (var _c = __values(this._results), _d = _c.next(); !_d.done; _d = _c.next()) {
var _e = __read(_d.value, 2), k = _e[0], v = _e[1];
var fbs_key = builder.createString(k);
var fbs_value = v.val.serialize(builder, { rule: v.rule });
schema.Result.startResult(builder);
schema.Result.addKey(builder, fbs_key);
schema.Result.addValue(builder, fbs_value);
schema.Result.addTyp(builder, result_types.get(v.typ));
result_entries.push(schema.Result.endResult(builder));
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
}
finally { if (e_3) throw e_3.error; }
}
var fbs_result_entries = schema.Results.createEntriesVector(builder, result_entries);
schema.Results.startResults(builder);
schema.Results.addEntries(builder, fbs_result_entries);
var fbs_results = schema.Results.endResults(builder);
var metric_entries = [];
try {
for (var _f = __values(this._metrics()), _g = _f.next(); !_g.done; _g = _f.next()) {
var _h = __read(_g.value, 2), k = _h[0], v = _h[1];
var fbs_key = builder.createString(k);
var fbs_value = v.serialize(builder);
schema.Metric.startMetric(builder);
schema.Metric.addKey(builder, fbs_key);
schema.Metric.addValue(builder, fbs_value);
metric_entries.push(schema.Metric.endMetric(builder));
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
}
finally { if (e_4) throw e_4.error; }
}
var fbs_metric_entries = schema.Metrics.createEntriesVector(builder, metric_entries);
schema.Metrics.startMetrics(builder);
schema.Metrics.addEntries(builder, fbs_metric_entries);
var fbs_metrics = schema.Metrics.endMetrics(builder);
schema.Message.startMessage(builder);
schema.Message.addMetadata(builder, fbs_metadata);
schema.Message.addResults(builder, fbs_results);
schema.Message.addMetrics(builder, fbs_metrics);
var fbs_message = schema.Message.endMessage(builder);
builder.finish(fbs_message);
return builder.asUint8Array();
};
return Case;
}());
export { Case };
//# sourceMappingURL=case.js.map